通过套接字验证消息RSA签名方案时出现问题

我试图通过套接字将签名消息从服务器发送到客户端。我无法验证消息。我尝试了基于维基上提供的代码示例的过滤和非过滤方法。我已经尝试了几乎所有我能在谷歌上找到的东西,但我被卡住了。

   SERVER:

   try
   {
      AutoSeededRandomPool rng;
      stringstream ss;
      string signature;

//      byte* signature = new byte[tdata->signer.MaxSignatureLength()];
//      if( NULL == signature )
//      {
//         throw Exception(Exception::OTHER_ERROR, "Invalid Signature");
//      }
//
//      size_t length = tdata->signer.SignMessage( rng, (const byte*) sendBuf.c_str(),
//          sendBuf.length(), signature );
      //string signature;
//    byte* message = (byte*) sendBuf.c_str();
//    SecByteBlock signature(tdata->signer.MaxSignatureLength(sendBuf.size()));
//
//    size_t signatureLen = tdata->signer.SignMessageWithRecovery(rng, message,
//             sendBuf.size(), NULL, 0, signature);
//
//    cout << "Signature Length: " << signatureLen << endl;
//    ss << signatureLen;
//    string len = ss.str();
//    string send;
//    send = (char*)signature.data();
//    send += " " + len;
      StringSource(sendBuf, true,
               new SignerFilter(rng, tdata->signer, new StringSink(signature),
                        true // putMessage
                        )// SignerFilter
                        );// StringSource

//    cout << "Signature: " << std::hex << signature << endl;
//    // Encode the message as an Integer
//    m = Integer((const byte *) sendBuf.c_str(), sendBuf.size());
//
//    //Encrypt
//    c = tdata->privateKey.CalculateInverse(rng, m);
//
//    //Turn the encrypted value into a string
//    ss << c;
//    sendBuf = ss.str();
//    ss.str("");
//    ss.clear();
//    cout << "Cipher Sent: " << sendBuf << endl;

      tdata->sockSource.Send((byte*)signature.c_str(), sizeof(signature));

   CLIENT:

   string signature, recovered;
   stringstream ss("");
   AutoSeededRandomPool rng;
   byte byteBuf[ 1000 ];

   try
   {
      // Retrieve message from socket
      cout << "Waiting for reply from server..." << endl;
      sockServer.Receive(byteBuf, sizeof(byteBuf));

      ss << byteBuf;
      string signature = ss.str();
      ss.str("");
      ss.clear();

//    byte sig[2048];
//    bool result = verifier.VerifyMessage( (const byte*)message.c_str(),
//        message.length(), sig, 2048 );
//
//    if( true == result )
//    {
//        cout << "Message Verified" << endl;
//    }
//    else
//    {
//        cout << "Message Verification Failed" << endl;
//    }
//    cout << endl << std::hex << "Cipher Received: " << byteBuf << endl;
//
//    SecByteBlock recovered(
//             verifier.MaxRecoverableLengthFromSignatureLength(length));
//
//    DecodingResult result = verifier.RecoverMessage(recovered, NULL, 0,
//             byteBuf, length);
//
//    if ( !result.isValidCoding )
//    {
//       throw Exception(Exception::OTHER_ERROR, "Invalid Signature");
//    }
//
//    ////////////////////////////////////////////////
//    // Use recovered message
//    size_t recoveredLen = result.messageLength;
//
//    assert(
//             0
//                      == memcmp(byteBuf, (const byte* )recovered,
//                               std::min(sizeof(byteBuf), recoveredLen)));

//     Convert message to a string
//    StringSource ss1(byteBuf, sizeof(byteBuf), true,
//             new StringSink(temp));
//
//    ss << byteBuf;
//    signature = ss.str();
//    ss.str("");
//    ss.clear();
//
//    cout << "Signature received: " << std::hex << signature << endl;
//
      StringSource(signature, true,
               new SignatureVerificationFilter(verifier,
                        new StringSink(recovered),
                        SignatureVerificationFilter::THROW_EXCEPTION
                                 | SignatureVerificationFilter::PUT_MESSAGE) // SignatureVerificationFilter
                                 );// StringSource

      cout << "Verified signature on message" << endl;
      return recovered;
//    return recovered;

//    //Convert the string to an Integer so we can calculate the inverse
//    c = Integer(recBuf.c_str());
//    r = serverKey.ApplyFunction(c);
//    cout << "r: " << r << endl;
//
//    // Recover the original message
//    size_t req = r.MinEncodedSize();
//    recovered.resize(req);
//    r.Encode((byte *) recovered.data(), recovered.size());
//    cout << "Recovered: " << recovered << endl;

   }
   catch ( Exception& e )
   {
      cerr << "caught Exception..." << endl;
      cerr << e.what() << endl;
      sockServer.ShutDown(SHUT_RDWR);
      return "";
   }