实例化CBC模式时出现Error 65537错误，求PyCryptoDome加密方案排查

Alright, let's tackle that Error 65537 you're facing when setting up AES-CBC mode for your client-server encrypted communication. First, let's clarify: this error almost always ties to invalid parameters being passed to the AES-CBC constructor—most commonly issues with the AES key length, IV (Initialization Vector) validity, or corrupted data from the RSA decryption step.

Here's a step-by-step breakdown to diagnose and fix this:

1. Verify Your AES Key Length is Compliant #

AES only supports three key sizes:

• 128-bit (16 bytes)
• 192-bit (24 bytes)
• 256-bit (32 bytes)

If your client generates a key that's not one of these lengths (e.g., a random string of arbitrary length, or bytes generated incorrectly), PyCryptoDome will throw this error. Double-check how you're generating the key:

# Correct way to generate a 128-bit AES key
from Crypto.Random import get_random_bytes
aes_key = get_random_bytes(16)  # Use 24 for 192-bit, 32 for 256-bit

Pro tip: Always validate the key length on both client and server side with an assertion, like assert len(aes_key) in (16,24,32), "Invalid AES key size".

2. Ensure the IV is Properly Configured #

CBC mode requires an IV that's exactly 16 bytes long (matching AES's block size). If you omit the IV, pass one of the wrong length, or reuse an IV incorrectly, you'll hit this error.

• The IV doesn't need to be secret, but it must be cryptographically random and unique for every encryption operation.
• Make sure you're passing it explicitly when instantiating the AES cipher:

from Crypto.Cipher import AES
iv = get_random_bytes(16)  # Generate once per encryption session
aes_cipher = AES.new(aes_key, AES.MODE_CBC, iv=iv)

Don't forget to send the IV from client to server (or vice versa) alongside the encrypted AES key—both sides need the same IV to encrypt/decrypt properly.

3. Check if the RSA-Decrypted AES Key is Corrupted #

Sometimes the issue isn't with AES itself, but with the RSA decryption step producing a damaged or incomplete AES key. To confirm:

• On the client side, print the hex representation of the original AES key: print(f"Client AES key: {aes_key.hex()}")
• On the server side, after decrypting, print the same: print(f"Server decrypted AES key: {aes_key.hex()}")
• If the two don't match, your RSA encryption/decryption flow is broken. Ensure:
  • Both client and server are using PKCS1_OAEP (not plain PKCS1_v1_5) for encryption/decryption.
  • The client is encrypting with the correct server public key, and the server is decrypting with the matching private key.
  • You're not truncating or modifying the encrypted AES key during transmission (e.g., using a messaging protocol that adds extra bytes without handling them).

4. Update PyCryptoDome and Validate Mode Constants #

Older versions of PyCryptoDome might have bugs related to mode instantiation. Upgrade to the latest stable version:

pip install --upgrade pycryptodome

Also, double-check that you're using the correct mode constant: AES.MODE_CBC (not a typo like MODE_CBC without the AES. prefix).

Example Working Code Snippets #

Client Side: #

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP, AES
from Crypto.Random import get_random_bytes
import socket

# Connect to server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("localhost", 12345))

# Receive server's RSA public key
server_pub_key_bytes = s.recv(4096)
server_pub_key = RSA.import_key(server_pub_key_bytes)

# Generate valid AES key and IV
aes_key = get_random_bytes(16)
iv = get_random_bytes(16)

# Encrypt AES key with RSA PKCS1_OAEP
cipher_rsa = PKCS1_OAEP.new(server_pub_key)
encrypted_aes_key = cipher_rsa.encrypt(aes_key)

# Send encrypted key and IV to server
s.sendall(encrypted_aes_key)
s.sendall(iv)

# Initialize AES-CBC cipher for communication
aes_cipher = AES.new(aes_key, AES.MODE_CBC, iv)
# ... proceed with encrypted messaging

Server Side: #

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP, AES
import socket

# Load RSA private key
private_key = RSA.import_key(open("private_key.pem").read())

# Set up server socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(("localhost", 12345))
s.listen(1)
conn, addr = s.accept()

# Send public key to client
conn.sendall(private_key.publickey().export_key())

# Receive encrypted AES key and IV
encrypted_aes_key = conn.recv(4096)
iv = conn.recv(16)

# Decrypt AES key
cipher_rsa = PKCS1_OAEP.new(private_key)
aes_key = cipher_rsa.decrypt(encrypted_aes_key)
assert len(aes_key) == 16, "Invalid AES key length after decryption"

# Initialize AES-CBC cipher
aes_cipher = AES.new(aes_key, AES.MODE_CBC, iv)
# ... proceed with encrypted messaging

Start with checking the key and IV lengths first—those are the most common culprits. If those check out, move to verifying the RSA decryption output.

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