RSA es un algoritmo de criptografía asimétrica basado en la dificultad matemática de factorizar números enteros grandes.

¿Qué es RSA?

RSA utiliza un par de claves (pública y privada) donde la clave pública se puede compartir libremente, mientras que la clave privada debe mantenerse secreta.

Fundamentos Matemáticos

Generación de Claves

  1. Elegir primos: Seleccionar dos números primos grandes p y q
  2. Calcular n: n = p × q (módulo)
  3. Calcular φ(n): φ(n) = (p-1) × (q-1) (función de Euler)
  4. Elegir e: e tal que 1 < e < φ(n) y gcd(e, φ(n)) = 1
  5. Calcular d: d tal que (e × d) mod φ(n) = 1

Claves Resultantes

  • Clave pública: (n, e)
  • Clave privada: (n, d)

Operaciones

Cifrado

C = M^e mod n

Donde:

  • C = texto cifrado
  • M = mensaje original
  • e = exponente público
  • n = módulo

Descifrado

M = C^d mod n

Donde:

  • M = mensaje descifrado
  • C = texto cifrado
  • d = exponente privado
  • n = módulo

Implementación

Generación de Claves

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Ejemplo de generación de claves RSA
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

# Generar par de claves RSA de 2048 bits
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)

# Obtener clave pública
public_key = private_key.public_key()

Cifrado con Clave Pública

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Cifrar con clave pública
from cryptography.hazmat.primitives.asymmetric import padding

message = b"Hello, World!"
ciphertext = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

Descifrado con Clave Privada

1
2
3
4
5
6
7
8
9

# Descifrar con clave privada
plaintext = private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

Firmas Digitales

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# Firmar con clave privada
from cryptography.hazmat.primitives import hashes

signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# Verificar con clave pública
try:
    public_key.verify(
        signature,
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("Firma válida")
except:
    print("Firma inválida")

Tamaños de Clave

Recomendaciones Actuales

  • 1024 bits: Obsoleto, no recomendado
  • 2048 bits: Mínimo recomendado actualmente
  • 3072 bits: Recomendado para aplicaciones críticas
  • 4096 bits: Para máxima seguridad

Consideraciones

  • Rendimiento: Claves más grandes = más lento
  • Seguridad: Claves más grandes = más seguro
  • Compatibilidad: Verificar soporte del sistema

Aplicaciones

Cifrado de Datos

  • Cifrado híbrido: RSA + AES
  • Intercambio de claves: Establecer claves simétricas
  • Cifrado de archivos: Archivos sensibles
  • Comunicaciones: Canales seguros

Autenticación

  • Firmas digitales: Verificar identidad
  • Certificados digitales: Infraestructura PKI
  • Login seguro: Autenticación sin contraseña
  • Integridad: Verificar no modificación

Protocolos

  • TLS/SSL: Handshake y autenticación
  • SSH: Autenticación de servidores
  • PGP/GPG: Cifrado de correo
  • S/MIME: Correo electrónico seguro

Seguridad

Fortalezas

  • Factorización: Dificultad matemática probada
  • Estándar: Ampliamente implementado
  • Flexible: Múltiples aplicaciones
  • Maduro: Años de análisis

Vulnerabilidades

  • Factorización: Avances en algoritmos
  • Implementación: Errores de programación
  • Side-channel: Ataques de canal lateral
  • Timing attacks: Ataques de tiempo

Mejores Prácticas

  • Tamaño de clave: Usar al menos 2048 bits
  • Padding: Usar OAEP para cifrado
  • Generación: Usar generadores seguros
  • Almacenamiento: Proteger claves privadas

Comparación con Otros Algoritmos

RSA vs ECC

  • RSA: Más maduro, claves más grandes
  • ECC: Más eficiente, claves más pequeñas
  • Rendimiento: ECC generalmente más rápido
  • Seguridad: Ambos son seguros cuando se implementan correctamente

RSA vs AES

  • RSA: Asimétrico, intercambio de claves
  • AES: Simétrico, cifrado de datos
  • Uso conjunto: RSA para claves, AES para datos
  • Híbrido: Combinación común en aplicaciones

Rendimiento

Operaciones Costosas

  • Generación de claves: Muy lenta
  • Cifrado/Descifrado: Moderadamente lenta
  • Firmas: Moderadamente lenta
  • Verificación: Relativamente rápida

Optimizaciones

  • Hardware: Aceleradores criptográficos
  • Software: Implementaciones optimizadas
  • Caché: Reutilizar claves generadas
  • Híbrido: RSA + AES para eficiencia

Mejores Prácticas

Generación de Claves

  • Tamaño: Usar al menos 2048 bits
  • Primos: Usar generadores seguros
  • Validación: Verificar propiedades matemáticas
  • Almacenamiento: Proteger claves privadas

Implementación

  • Padding: Usar OAEP para cifrado
  • Firmas: Usar PSS para firmas
  • Librerías: Usar librerías probadas
  • Testing: Probar implementaciones

Gestión

  • Rotación: Rotar claves regularmente
  • Backup: Respaldar claves de forma segura
  • Revocación: Revocar claves comprometidas
  • Auditoría: Registrar uso de claves

Conceptos Relacionados

Referencias