Backup

from Crypto.Cipher import PKCS1_OAEP
from Crypto.PublicKey import RSA

from Crypto.Hash import SHA256, SHA512, SHA1
from Crypto.Signature import PKCS1_PSS
import binascii
import secrets


def encrypt_long_message(message, key):
    # Set the chunk size to encrypt in bytes
    chunk_size_bytes = 190

    # Encrypt the message using the provided RSA key
    cipher = PKCS1_OAEP.new(key)

    # Break up the message into smaller chunks and encrypt each chunk separately
    offset = 0
    chunks = []
    while offset < len(message):
        chunk = message[offset:offset + chunk_size_bytes]
        if len(chunk) % chunk_size_bytes != 0:
            chunk += b' ' * (chunk_size_bytes - len(chunk) % chunk_size_bytes)
        chunks.append(cipher.encrypt(chunk))
        offset += chunk_size_bytes

    # Concatenate the encrypted chunks together and return the result
    return b''.join(chunks)


def decrypt_long_message(encrypted_message, key):
    # Set the chunk size to decrypt in bytes
    chunk_size_bytes = 256

    # Decrypt the message using the provided RSA key
    cipher = PKCS1_OAEP.new(key)

    # Break up the message into smaller chunks and decrypt each chunk separately
    offset = 0
    decrypted_chunks = []
    while offset < len(encrypted_message):
        chunk = encrypted_message[offset:offset + chunk_size_bytes]
        decrypted_chunks.append(cipher.decrypt(chunk))
        offset += chunk_size_bytes

    # Concatenate the decrypted chunks together and return the result
    decrypted_message = b''.join(decrypted_chunks)

    # Remove any padding that may have been added
    decrypted_message = decrypted_message.strip()

    return decrypted_message


class Client:
    def __init__(self):
        self.rsa_length_bits = 2048
        self.hash_func = SHA512

        # Enc and sign
        self.client_rsa_enc_key = RSA.generate(2048)
        self.client_rsa_sign_key = RSA.generate(2048)

        self.signature = None
        self.client_private_key = None

        self.num_rand_bytes = 32
        self.private_num_rand_bytes = 48
        self.premaster_secret = ''
        self.master_secret = ''

        self.client_write_mac_key = ''
        self.server_write_mac_key = ''
        self.client_write_key = ''
        self.server_write_key = ''

        self.block = ''
        self.client_public_random = secrets.token_bytes(self.num_rand_bytes)
        self.client_private_random = secrets.token_bytes(self.private_num_rand_bytes)

    #sha512(message).digest()
    def generate_keys_client_side(self):
        client_rsa_enc_key = self.client_rsa_enc_key.e, self.client_rsa_enc_key.n
        client_rsa_sign_key = self.client_rsa_sign_key.e, self.client_rsa_sign_key.n

        print("Client RSA Public Enc Key = ", client_rsa_enc_key) # Public key, n
        print("Client RSA Public Sign Key = ", client_rsa_sign_key) # Public key, n

    def generate_public_random_32_bytes(self):
        # Generate 32 random bytes on both sides (client_public_random, server_public_random)
        print("Client Public 32 random bytes = ", self.client_public_random)

    def generate_private_random_48_bytes(self):
        print("Client Private 48 random bytes = ", self.client_private_random)

    def sign_and_send(self, server_rsa_enc_key):
        client_private_random_hash = SHA512.new(self.client_private_random)
        client_signature_scheme = PKCS1_PSS.new(self.client_rsa_sign_key)
        client_signature = client_signature_scheme.sign(client_private_random_hash)

        encrypted_signature_chunk = encrypt_long_message(client_signature, server_rsa_enc_key)
        return encrypted_signature_chunk

    def receive_signature_from_client_and_verify(self, server_rsa_enc_key, encrypted_signature_chunk):
        decrypted_signature = decrypt_long_message(encrypted_signature_chunk, server_rsa_enc_key)
        verifier = PKCS1_PSS.new(self.client_rsa_sign_key.publickey())

        client_private_random_hash = SHA512.new(self.client_private_random)
        try:
            verifier.verify(client_private_random_hash, decrypted_signature)
            print("The signature is authentic.")
        except:
            print("The signature is not authentic.")



    def combine_private_randoms(self, client_private_random, server_private_random):
        self.premaster_secret = client_private_random + server_private_random
        print("Pre master secret = ", self.premaster_secret)

    def generate_master_secret(self, client_public_random, server_public_random):
        self.concat_public_random = client_public_random + server_public_random
        self.concat_public_random = self.concat_public_random.encode()

        self.master_secret = prf(hashlib.sha256, self.premaster_secret.encode(), b'master secret', self.concat_public_random, b'seed', self.private_num_rand_bytes)

        print("Master secret = ", self.master_secret)

    def generate_with_prf(self):
        total_bytes = 32 + 32 + 2 + 2

        #drop the message
        self.block = prf(self.hash_func, self.master_secret, b'key expansion', self.concat_public_random, b'seed', total_bytes)
        #prf(hashlib.sha256, self.master_secret, b'master secret', self.concat_public_random, b'seed', self.private_num_rand_bytes)

        self.client_write_mac_key = self.block[0:33]
        self.server_write_mac_key = self.block[32:63]
        self.client_write_key = self.block[64:65]
        self.server_write_key = self.block[66:67]

        print("Block = ", self.block)
        print("client_write_mac_key = " + str(self.client_write_mac_key))
        print("server_write_mac_key = " + str(self.server_write_mac_key))
        print("client_write_key = " + str(self.client_write_key))
        print("server_write_key = " + str(self.server_write_key))


    def send_message_from_server(self, message):
        # 13
        encrypted = encrypt(message, self.client_write_key)
        authenticated = hmac(encrypted, self.server_write_mac_key)

        print("Encrypted = ", encrypted)
        print("Authenticated = ", authenticated)

    def decrypt_message(self, message, authentication_code):
        decrypted = decrypt(message, self.client_write_key)

        authenticated = hmac(decrypted, self.server_write_mac_key)
        # Check
        if authentication_code == authenticated:
            print("Jó!")

        return None

    def verify_authentication_code(self, message):
        # 13

        return None


    def send_message(self, private_key):
        signed_client_private_random = sign_message(private_key, self.hash_func, message)
        send = rsa_oaep_encode(self.rsa_length_bits, b'', signed_client_private_random) #Place It here

        print("Send = ", str(send));

    def receive_message(self, encoded_message):
        decoded_message = rsa_oaep_decode(256, b'', encoded_message)
        return message