Fundamentos y criptografía

📐 Fundamento

Principios fundamentales:

Modelo de amenazas (Threat Model):

Antes de defender, hay que saber qué se defiende y de quién:

1. ¿Qué activos tenemos? (datos de clientes, infraestructura, reputación)
2. ¿Quiénes son los atacantes? (script kiddies, criminales, estado-nación, insiders)
3. ¿Qué pueden hacer? (ataques de red, ingeniería social, acceso físico)
4. ¿Qué tan motivados están?
5. ¿Qué pasaría si tienen éxito?

STRIDE — taxonomía de amenazas (Microsoft):

📐 Fundamento

AES (Advanced Encryption Standard): el estándar moderno.

• Tamaños de clave: 128, 192, 256 bits.
• AES-256 es virtualmente irrompible con tecnología actual.

Modos de operación:

Demostración: por qué ECB es malo

Si cifrás una imagen con ECB, el patrón sigue siendo visible. Con CBC o GCM, el resultado parece ruido aleatorio.

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

# Generar clave aleatoria de 256 bits
clave = AESGCM.generate_key(bit_length=256)

aesgcm = AESGCM(clave)
nonce = os.urandom(12)  # nonce de 96 bits — único por mensaje

# Cifrar
mensaje = b"Numero de tarjeta: 4532-1234-5678-9012"
asociado = b"pedido_id=12345"  # datos asociados (no cifrados pero autenticados)

ciphertext = aesgcm.encrypt(nonce, mensaje, asociado)
print(f"Cifrado: {ciphertext.hex()}")

# Descifrar
plaintext = aesgcm.decrypt(nonce, ciphertext, asociado)
print(f"Descifrado: {plaintext.decode()}")

# Si alguien modifica el ciphertext o el asociado, decrypt falla
# → garantía de integridad además de confidencialidad

Reglas de oro:

• Nunca reutilizar un nonce con la misma clave — rompe la seguridad de GCM.
• Generar la clave con os.urandom, nunca con random (no es criptográficamente seguro).
• Rotar claves periódicamente y guardarlas en un KMS (Key Management Service: AWS KMS, HashiCorp Vault).

📐 Fundamento

RSA — el algoritmo asimétrico clásico:

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes, serialization

# Generar par de claves
clave_privada = rsa.generate_private_key(public_exponent=65537, key_size=2048)
clave_publica = clave_privada.public_key()

# Cifrar con clave pública
mensaje = b"Mi mensaje secreto"
ciphertext = clave_publica.encrypt(
    mensaje,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Descifrar con clave privada
plaintext = clave_privada.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(plaintext.decode())  # "Mi mensaje secreto"

# Firma digital
firma = clave_privada.sign(
    mensaje,
    padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
    hashes.SHA256()
)

# Verificar firma con clave pública
clave_publica.verify(
    firma,
    mensaje,
    padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
    hashes.SHA256()
)  # No lanza excepción → firma válida

Comparación de algoritmos asimétricos:

Cifrado híbrido (lo que realmente se usa):

Como asimétrico es lento, en la práctica se combina:

1. Generar una clave simétrica aleatoria (clave de sesión)
2. Cifrar el mensaje grande con la clave simétrica (AES)
3. Cifrar la clave simétrica con la pública del destinatario (RSA)
4. Enviar: ciphertext_simétrico + clave_de_sesión_cifrada

Esto es exactamente lo que hace TLS internamente.

📐 Fundamento

Una función hash: transforma datos de cualquier tamaño en una huella de tamaño fijo.

import hashlib

mensaje = b"Pupusas de queso"
print(hashlib.sha256(mensaje).hexdigest())
# c8e9...9aa3 (64 caracteres hex = 256 bits)

# Cualquier cambio mínimo cambia el hash completamente
mensaje2 = b"pupusas de queso"  # solo cambia mayúscula
print(hashlib.sha256(mensaje2).hexdigest())
# 1f4b...8e02 (completamente diferente — efecto avalancha)

Propiedades criptográficas:

Algoritmos hash:

Hashing para contraseñas — NUNCA usar SHA por sí solo:

# MAL — SHA-256 puro es muy rápido, fácil de bruteforcear
password_hash = hashlib.sha256(b"contrasena123").hexdigest()
# Un GPU moderno puede probar miles de millones de hashes/segundo

# BIEN — usar bcrypt, scrypt, o Argon2 (lentos y con sal automática)
import bcrypt
password_hash = bcrypt.hashpw(b"contrasena123", bcrypt.gensalt(rounds=12))
# bcrypt es deliberadamente lento → solo se pueden probar miles/segundo

HMAC (Hash-based Message Authentication Code):

Verifica que un mensaje no fue modificado y que viene de quien dice:

import hmac, hashlib

clave_compartida = b"clave_secreta_compartida_entre_partes"
mensaje = b"transferencia: $100 de A a B"

# Emisor genera HMAC
mac = hmac.new(clave_compartida, mensaje, hashlib.sha256).hexdigest()

# Receptor verifica
mac_recibido = mac
mac_calculado = hmac.new(clave_compartida, mensaje, hashlib.sha256).hexdigest()

if hmac.compare_digest(mac_recibido, mac_calculado):
    print("Mensaje válido y no modificado")

Importante: Usar hmac.compare_digest() en lugar de == para evitar timing attacks (un atacante puede medir cuánto tarda la comparación letra por letra y deducir el HMAC correcto).

📐 Fundamento

TLS Handshake (TLS 1.3 simplificado):

Cliente                                    Servidor
   │                                            │
   │ ──── ClientHello (cipher suites, ECDHE) ──→│
   │                                            │
   │ ←──── ServerHello + Certificate + ────────│
   │       Firma digital + ECDHE_pubkey         │
   │                                            │
   │ Verifica certificado contra CAs confiables │
   │ Calcula clave maestra (ECDHE)              │
   │                                            │
   │ ──── Finished (cifrado con clave maestra) ─→│
   │                                            │
   │ ←──── Aplicación: HTTP cifrado ────────────│

Verificación del certificado:

1. El servidor envía su certificado (contiene clave pública + dominio + firma de CA).
2. El cliente verifica que la firma sea válida usando la clave pública de la CA.
3. La clave pública de la CA está pre-instalada en el sistema operativo / navegador.
4. El cliente verifica que el dominio del certificado coincida con el dominio al que se conectó.
5. Verifica que el certificado no esté expirado o revocado.

Cadena de confianza:

Root CA (DigiCert, Let's Encrypt, etc.)  ← preinstalada en SO
   │ firma
   ▼
Intermediate CA
   │ firma
   ▼
Certificate de la-esquina.com  ← contiene clave pública del servidor

Let's Encrypt: Autoridad Certificadora gratuita y automatizada. Permite obtener certificados TLS válidos sin costo:

# En el servidor de producción
certbot --nginx -d la-esquina.com -d www.la-esquina.com
# → instala automáticamente certificado válido por 90 días
# → certbot lo renueva automáticamente

Forward Secrecy: Si la clave privada del servidor es comprometida en el futuro, los mensajes pasados siguen siendo seguros (porque la clave de sesión se generó efímeramente con ECDHE y nunca se guardó). TLS 1.3 lo hace por defecto.