Получение объекта «байта» не имеет ошибки атрибута «шифровать» при использовании открытого ключа для гибридного шифрован ⇐ Python

[Anonymous]

Я пытаюсь реализовать симметричное и асимметричное шифрование в программе, которая способна подписывать и шифровать, а затем проверять и расшифровать файлы. Я использую библиотеку примитивов Cryptograby Hazmat. Я сталкиваюсь с ошибкой, которая заставляет мой шифрование RSA провалиться, когда я пытаюсь зашифровать ее с помощью своего публичного ключа RSA. Я вытаскиваю общедоступный ключ из отдельного файла. Я знаю, что моим ключом должен быть криптография введите на работу шифрование. Я прокомментировал попытку, кроме линий для сейчас. _rust.openssl.rsa.rsapublickey '>, но затем, когда я проверяю тип в функции encrypt_aes_key_rsa, теперь это байты. Я не могу понять, где и почему это изменение происходит. Функция подписания и/или шифрование AES, но я не могу в течение жизни понять, в чем проблема. Любая помощь будет очень признателен, спасибо! < /P>
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.serialization import load_pem_public_key, load_pem_private_key, load_der_public_key, load_der_private_key
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import sys, argparse, os

#Argument parser for encypt and decrypt commands
def parse_args():
parser = argparse.ArgumentParser(description='Encrypt/Decrypt')
parser.add_argument('-e', '--encrypt', nargs=4)
parser.add_argument('-d', '--decrypt', nargs=4)

return parser.parse_args()

#Serialize the key from the public key PEM file
def read_public_key(public_key_pem):
with open(public_key_pem, 'rb') as key_file:
public_key = load_pem_public_key(key_file.read())
return public_key

#Serialize the key from the private key PEM file
def read_private_key(private_key_pem):
with open(private_key_pem, 'rb') as key_file:
private_key = load_pem_private_key(key_file.read(),password = None)
return private_key

#Encrypt the message with AES key
def encrypt_message_aes(message, aes_key):
iv = os.urandom(16)
cipher = Cipher(algorithms.AES(aes_key), modes.GCM(iv))
encryptor = cipher.encryptor()
ciphertext = encryptor.update(message) + encryptor.finalize()
return ciphertext + iv

#Encrypt the AES key using RSA
def encrypt_aes_key_rsa(public_key, aes_key):
encrypted_aes_key = public_key.encrypt(
aes_key,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
return encrypted_aes_key

#Decrypt the ciphertext file using the recipient's private key
def decrypt_message_aes(encrypted_message, key):
iv = encrypted_message[:16]
ciphertext = encrypted_message[16:]
cipher = Cipher(algorithms.AES(key), modes.GCM(iv), backend=default_backend())
decryptor = cipher.decryptor()
padded_message = decryptor.update(ciphertext) + decryptor.finalize()
padding_len = padded_message[-1]
return padded_message[:-padding_len]

#Decrypt the AES key
def decrypt_aes_key_rsa(encrypted_aes_key, private_key):
aes_key = private_key.decrypt(
encrypted_aes_key,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
return aes_key

#Sign message with sender's private key
def sign_message(private_key, message):
signature = private_key.sign(
message,
padding.PKCS1v15(),
hashes.SHA256()
)
return signature

#Verify the message signature
def verify_signature(message, signature, public_key):
public_key.verify(
signature,
message,
padding.PKCS1v15(),
hashes.SHA256()
)
return True

#Main function
def main():
args = parse_args()

#Encrypt command
if args.encrypt:
public_key_pem = args.encrypt[0]
public_key = read_public_key(public_key_pem)
private_key_pem = args.encrypt[1]
private_key = read_private_key(private_key_pem)
ciphertext_file = args.encrypt[3]
input_plaintext_file = args.encrypt[2]

with open(input_plaintext_file, "rb") as file:
message = file.read()

with open("aes_key_file.pem", "rb") as file:
aes_key = file.read()

encrypt_message_aes(message, aes_key)
encrypt_aes_key_rsa(aes_key, public_key_pem)
signature = sign_message(message, public_key_pem)

with open(ciphertext_file, "wb") as file:
file.write(ciphertext + iv + signature)

with open("encrypted_aes_key_file", "wb") as f:
f.write(encrypted_aes_key)
with open("signature_file", "wb") as f:
f.write(signature)

#Decrypt command
if args.decrypt:
private_key_pem = args.decrypt[0]
public_key_pem = args.decrypt[1]
ciphertext_file = args.decrypt[2]
input_plaintext_file = args.decrypt[3]

with open("encrypted_message_file", "rb") as f:
encrypted_message = f.read()
with open("encrypted_aes_key_file", "rb") as f:
encrypted_aes_key = f.read()
with open("signature_file", "rb") as f:
signature = f.read()

with open(ciphertext_file, "rb") as file:
encrypted_message = file.read()

decrypted_aes_key = decrypt_aes_key_rsa(encrypted_aes_key, private_key_pem)
decrypted_message = decrypt_message_aes(encrypted_message, decrypted_aes_key)
is_valid_signature = verify_signature(encrypted_message, signature, public_key_pem)

with open(input_plaintext_file, "wb") as file:
file.write(is_valid_signature)

if __name__ == "__main__":
main()


Подробнее здесь: https://stackoverflow.com/questions/794 ... lic-key-fo