Crypto++ RSA签名验证失败排查请求：OOP钱包应用问题

Hey there! Let’s break down the most common reasons your signature verification keeps returning false—this is super typical when getting started with asymmetric crypto in Crypto++, so don’t sweat it too much. Let’s go through the key checks tailored to your OOP wallet setup:

1. Mismatched Hash Algorithms Between Signing and Verification #

Crypto++ ties RSA signatures to a specific hash function (like SHA-256 or SHA-512), and you must use the exact same one for both signing and verifying. For example:

• If you sign with RSASSA_PKCS1v15_SHA256_Signer, you need to verify with RSASSA_PKCS1v15_SHA256_Verifier
• Mixing SHA-1 and SHA-256 (or any other pair) will instantly break verification.

Double-check your Wallet signing code and Transaction verification code to ensure the hash algorithm is identical across both operations.

2. Inconsistent Data Being Signed/Verified #

Signatures are tied to the exact bytes of the data you’re signing. If the sender’s Transaction data (like amount, receiver address, timestamp) is serialized differently than what the receiver uses for verification, their hashes won’t match—making verification fail.

For example:

• Sender converts the amount to a string as "100.00" but receiver uses "100"
• Sender includes a hidden newline or whitespace in the data, while the receiver doesn’t

Fix this by creating a strict serialization method for your Transaction class (e.g., a Serialize() method that outputs a fixed-format byte stream or string) and use this exact output for both signing and verifying.

3. Invalid Public/Private Key Pairing #

Your Wallet class generates a private key and corresponding public key—but if this pairing is broken, verification will never work. Common issues here:

• You’re generating a public key separately instead of deriving it from the private key (correct way: RSA::PublicKey publicKey(privateKey);)
• You’re using the wrong public key for verification (e.g., verifying with the receiver’s public key instead of the sender’s)
• The key generation process has a bug (e.g., not using a proper random pool like AutoSeededRandomPool when generating keys)

Verify that each Wallet’s public key is directly derived from its own private key, and that during verification, you’re using the sender’s public key, not anyone else’s.

4. Broken Signature Encoding/Decoding #

If you’re storing the signature as a string (e.g., Base64) in your Transaction class, you need to ensure encoding and decoding are identical. For example:

• If you encode the signature with Base64Encoder (with default settings) when signing, you must decode it with Base64Decoder (same settings) before verifying
• Skipping decoding or using inconsistent Base64 options (like line breaks or padding) will corrupt the signature bytes

5. Example of a Working Sign/Verify Flow #

Here’s a quick snippet to reference for your Wallet and Transaction code:

// Sender Wallet: Signing a transaction
AutoSeededRandomPool rng;
string txData = m_transaction->Serialize(); // Your strict serialization method

RSASSA_PKCS1v15_SHA256_Signer signer(m_privateKey);
vector<byte> signature(signer.MaxSignatureLength());
size_t sigLen = signer.SignMessage(rng, (const byte*)txData.data(), txData.size(), signature.data());
signature.resize(sigLen);

// Encode to Base64 for storage in Transaction
string sigBase64;
StringSink ss(sigBase64);
Base64Encoder encoder(ss);
encoder.Put(signature.data(), signature.size());
encoder.MessageEnd();
m_transaction->SetSignature(sigBase64);

// Receiver: Verifying the transaction
string receivedTxData = receivedTransaction->Serialize();
string receivedSigBase64 = receivedTransaction->GetSignature();

// Decode Base64 back to bytes
vector<byte> receivedSignature;
StringSource ss(receivedSigBase64, true, new Base64Decoder(new VectorSink(receivedSignature)));

RSASSA_PKCS1v15_SHA256_Verifier verifier(senderWallet->GetPublicKey());
bool isValid = verifier.VerifyMessage(
    (const byte*)receivedTxData.data(), receivedTxData.size(),
    receivedSignature.data(), receivedSignature.size()
);

Start with checking the hash algorithm and data serialization first—those are the most frequent culprits. If you’re still stuck, sharing a minimal snippet of your signing/verification code would help narrow it down further!

内容的提问来源于stack exchange，提问作者Happy ITWala