RSA with AES 128

Question

This is my protocol:

Encryption and signing - user A

1. cipher using the public key from user B
2. sign the encrypted message with the private key A

Verifying and decrypting - user B

3. verify the signature with the public key A
4. decrypt the message with the private key B

The private key A and B are the same (128 bit)

I want to send the text using this protocol with AES in mode CBC so i create this code but doesnt work ,apperar in signature:

bytes object has no attribute n

the code is the following:

    def firmar(self, datos):

        try:
            h = SHA256.new(datos)

            signature = pss.new(self.keyprivada).sign(h)
            return signature
        except (ValueError, TypeError):
            return None

    def comprobar(self, text, signature):

        h = SHA256.new(text)

        print(h.hexdigest())
        verifier = pss.new(self.keypublica)
        try:
            verifier.verify(h, signature)
            return True
        except (ValueError, TypeError):
            return False

Answer 1

This section is no longer relevant as the code has changed

Firstly, you are usine ECB this is insecure due to the relationship between text and its output being constant.

Secondly, CBC requires an IV hence a different implementation would be required.

Lastly and most crucially:

AES is NOT an asymmetric encryption algorithm

meaning that it must be encrypted and decrypted with the same key. You use the public and the private keys as you would with asymmetrical encryption methods.

An alternative:

If you were to implement RSA properly you could then generate a random byte array and use that as your key, then send it encrypted to the recipient to decrypt it and use it as the key to decrypt the aes as it would be the same.

Now:

You use the private key to sign the data... RSA requires you to use the public key (now private - not distributed) to encrypt it however you cannot decrypt something encrypted with the private key with the public key. Instead you distribute the ‘private key’ for decryption and keep the ‘public key’ for encryption so no one else can encrypt or sign the data.

WHAT are you doing!

There is a relationship between public and private keys! You cannot just use random byte arrays.

Read the Wikipedia article.