在密碼學 Python 庫中使用 RSA 加密簽名消息

Question

我是密碼學的新手，抱歉，如果我只是想做一些愚蠢的事情。

所以，如果我試圖以正確的方式或不正確的方式做錯事或不管它是什么，請不要猶豫。

我想使用 RSA，我有兩個人：Alice 和 Bob。

起初，我想用 Alice 的私鑰加密消息，然后用 Bob 的公鑰加密加密后的消息，以保證消息的完整性/真實性和機密性。

我了解到無法使用私鑰加密，消息需要簽名然后驗證。

我已經看到我需要簽名的消息和未簽名的消息來驗證簽名。 根據我目前的研究，我有兩個選擇：

• 加密兩條消息，一條有簽名，一條沒有，解密后檢查簽名，
• 使用分隔符加密消息和簽名消息的串聯，解密文本，使用分隔符獲取兩者，然后檢查簽名。

我已經決定了第二個選項。

但是用這種方法我有一個可以用RSA密鑰加密的長度錯誤，也許正確的選擇是像@Topaco說的那樣：

• 加密消息
• 簽署加密信息
• 都給鮑勃
• 使用消息驗證簽名
• 最后，解密加密的消息？

但是用這個方法，我們要給Bob發送2條不同的消息（？）我覺得很奇怪

這是我的代碼：

from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.asymmetric import rsa, utils

# Generate private key for Alice
alice_private_key = rsa.generate_private_key(public_exponent=65537, key_size=4096)

# Get the public key for Alice
alice_public_key = alice_private_key.public_key()

# Generate private key for Bob
bob_private_key = rsa.generate_private_key(public_exponent=65537, key_size=4096)

# Get the public key for Bob
bob_public_key = bob_private_key.public_key()

# Sign the message using Alice's private key
message = b"Hello, world!"
signature = alice_private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# Concatenate the message and the signature using a separator
separator = b'|'
signed_message = message + separator + signature

# Encrypt the signed message using Bob's public key
ciphertext = bob_public_key.encrypt(
    signed_message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Print the ciphertext
print(ciphertext)

# Decrypt the package using Bob's private key
plaintext = bob_private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Get the signature and message
# signature_length = 256  # assuming the signature is 256 bytes long
# signature = plaintext[-signature_length:]
# message = plaintext[:-signature_length]
# Split the plaintext to get the signature and message using the separator
message, signature = plaintext.split(separator)

# Verify the signature using Alice's public key
try:
    alice_public_key.verify(
        signature,
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("Message send by Alice !")
except InvalidSignature as e:
    print("Message not send by Alice !")

預先感謝您的幫助 ！

Answer 1

在@Topaco 的幫助下，結果是下面的工作代碼。 但是為了確保消息的真實性/完整性和機密性，必須發送 2 條消息對我來說仍然感覺很奇怪。

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.asymmetric import rsa

# Generate private key for Alice
alice_private_key = rsa.generate_private_key(public_exponent=65537, key_size=4096)

# Get the public key for Alice
alice_public_key = alice_private_key.public_key()

# Generate private key for Bob
bob_private_key = rsa.generate_private_key(public_exponent=65537, key_size=4096)

# Get the public key for Bob
bob_public_key = bob_private_key.public_key()

message = b"Hello, world!"
print(message)

# Encrypt the message using Bob's public key
encoded_message = bob_public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Sign the encoded message using the alice's private key
signed_encoded_message = alice_private_key.sign(
    encoded_message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# Print the encoded_message (To virtually send these to Bob)
print(encoded_message)
print(signed_encoded_message)

# Verify the signature using Alice's public key
alice_public_key.verify(
    signed_encoded_message,
    encoded_message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# If the previous block doesn't raise an InvalidSignature exception
# we can decrypt the encoded_message

# Decrypt the package using Bob's private key
decoded_message = bob_private_key.decrypt(
    encoded_message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Bob have the Alice's message
print(decoded_message)