CriptoGraphy

gistfile1.txt

class PolynomialMultiKeyEncryption:
    def __init__(self, raw_data: bytes = None):
        self.prime = 2**127 - 1
        if raw_data:
            self.model_bytes = raw_data
            self.secret_value = random.randint(1000, 9999)
            self.coefficients = [self.secret_value] + [random.randint(1, self.prime-1) for _ in range(2)]
            self.salt = os.urandom(16)
            self.encryption_key = self._derive_encryption_key(self.secret_value)
            self.encrypted_data = self._encrypt_data()
            
    def _derive_encryption_key(self, secret: int) -> bytes:
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=self.salt,
            iterations=100000
        )
        return kdf.derive(secret.to_bytes(16, 'big'))
    
    def _encrypt_data(self) -> bytes:
        iv = os.urandom(16)
        cipher = Cipher(algorithms.AES(self.encryption_key), modes.GCM(iv), backend=default_backend())
        encryptor = cipher.encryptor()
        encrypted = encryptor.update(self.model_bytes) + encryptor.finalize()
        return base64.b64encode(iv + encryptor.tag + encrypted)

    def decrypt_data(self) -> bytes:
        data = base64.b64decode(self.encrypted_data)
        iv, tag, encrypted = data[:16], data[16:32], data[32:]
        cipher = Cipher(algorithms.AES(self.encryption_key), modes.GCM(iv, tag), backend=default_backend())
        decryptor = cipher.decryptor()
        return decryptor.update(encrypted) + decryptor.finalize()

    def _evaluate_polynomial(self, x: int) -> int:
        x_mod = x % self.prime
        result = 0
        for power, coeff in enumerate(self.coefficients):
            term = coeff
            for _ in range(power):
                term = (term * x_mod) % self.prime
            result = (result + term) % self.prime
        return result

    def generate_new_key(self) -> str:
        x = random.randint(1, 1000000)
        y = self._evaluate_polynomial(x)
        return f"{x}-{y}"