Ejemplo: Implementación segura de cifrado híbrido

from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
import os

class CifradoHibrido:
    """Implementa cifrado híbrido: RSA + AES"""
    
    def __init__(self):
        # Generar par de claves RSA
        self.private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=2048
        )
        self.public_key = self.private_key.public_key()
    
    def cifrar(self, mensaje):
        """Cifra mensaje usando RSA + AES"""
        # Generar clave AES aleatoria
        aes_key = os.urandom(32)  # 256 bits
        iv = os.urandom(16)       # 128 bits
        
        # Cifrar mensaje con AES
        cipher = Cipher(algorithms.AES(aes_key), modes.CBC(iv))
        encryptor = cipher.encryptor()
        
        # Padding del mensaje
        padded_message = self._pad_message(mensaje.encode())
        mensaje_cifrado = encryptor.update(padded_message) + encryptor.finalize()
        
        # Cifrar clave AES con RSA
        clave_aes_cifrada = self.public_key.encrypt(
            aes_key,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        
        return {
            'clave_cifrada': clave_aes_cifrada,
            'iv': iv,
            'mensaje_cifrado': mensaje_cifrado
        }
    
    def descifrar(self, datos_cifrados):
        """Descifra mensaje usando RSA + AES"""
        # Descifrar clave AES con RSA
        aes_key = self.private_key.decrypt(
            datos_cifrados['clave_cifrada'],
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        
        # Descifrar mensaje con AES
        cipher = Cipher(algorithms.AES(aes_key), modes.CBC(datos_cifrados['iv']))
        decryptor = cipher.decryptor()
        mensaje_padded = decryptor.update(datos_cifrados['mensaje_cifrado']) + decryptor.finalize()
        
        # Remover padding
        mensaje = self._unpad_message(mensaje_padded)
        return mensaje.decode()
    
    def _pad_message(self, message):
        """Aplica padding PKCS7"""
        block_size = 16
        padding_length = block_size - (len(message) % block_size)
        padding = bytes([padding_length] * padding_length)
        return message + padding
    
    def _unpad_message(self, padded_message):
        """Remueve padding PKCS7"""
        padding_length = padded_message[-1]
        return padded_message[:-padding_length]

# Uso del sistema
crypto_system = CifradoHibrido()
mensaje_original = "Información altamente confidencial"

# Cifrar
datos_cifrados = crypto_system.cifrar(mensaje_original)
print("Mensaje cifrado exitosamente")

# Descifrar
mensaje_descifrado = crypto_system.descifrar(datos_cifrados)
print(f"Mensaje descifrado: {mensaje_descifrado}")