Funciones Hash Criptográficas: Guía Completa

Las funciones hash criptográficas son los caballos de batalla silenciosos de la seguridad moderna. Cada vez que inicias sesión en un sitio web, subes código a Git, descargas un archivo o realizas una transacción de Bitcoin, las funciones hash trabajan entre bastidores. Sin embargo, la mayoría de los desarrolladores interactúan con ellas a diario sin entender realmente qué hacen, ni qué puede salir terriblemente mal cuando se usan incorrectamente.

Esta guía cubre todo: las matemáticas, la historia, los algoritmos rotos, los estándares modernos y el código práctico que necesitas para usar las funciones hash correctamente.

1. ¿Qué Son las Funciones Hash Criptográficas?

Una función hash criptográfica toma una entrada de cualquier tamaño y produce una salida de tamaño fijo, llamada resumen o hash. Por ejemplo, SHA-256 siempre produce exactamente 256 bits (64 caracteres hexadecimales), independientemente de si la entrada es un solo carácter o un archivo de película completo.

Propiedades Fundamentales

Determinista: La misma entrada siempre produce la misma salida. SHA-256("hello") siempre devolverá 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824.

Rápido de calcular: Calcular un hash debería tomar milisegundos. Esta eficiencia es crítica para las verificaciones de integridad de archivos y las firmas digitales, aunque se convierte en un problema para el hash de contraseñas (más sobre eso después).

Resistencia a la preimagen (unidireccional): Dado un hash de salida H, debe ser computacionalmente inviable encontrar cualquier entrada m tal que hash(m) = H. No se puede hacer ingeniería inversa para obtener los datos originales solo a partir del hash.

Resistencia a la segunda preimagen: Dada una entrada m1, debe ser inviable encontrar una entrada diferente m2 tal que hash(m1) = hash(m2). Incluso si un atacante conoce tus datos originales, no puede encontrar una entrada diferente que produzca el mismo hash.

Resistencia a colisiones: Debe ser inviable encontrar cualquier par de entradas distintas m1 y m2 tal que hash(m1) = hash(m2). Este es un requisito más fuerte que la resistencia a la segunda preimagen.

Efecto avalancha: Un pequeño cambio en la entrada — incluso un solo bit — cambia completamente la salida. Cambiar "hello" por "hellp" produce un hash completamente diferente sin relación aparente con el original.

SHA-256("hello") = 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
SHA-256("hellp") = 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca7

Estos dos hashes no comparten ninguna relación predecible — eso es el efecto avalancha en acción.

2. Breve Historia de los Algoritmos Hash

MD5 (1991)

Ronald Rivest diseñó MD5 como mejora sobre MD4. Produce un resumen de 128 bits y fue ampliamente adoptado durante los años 90 para sumas de verificación y almacenamiento de contraseñas. Durante más de una década, MD5 fue la elección predeterminada para muchas aplicaciones de seguridad.

SHA-1 (1995)

La Agencia de Seguridad Nacional (NSA) diseñó SHA-1 (Secure Hash Algorithm 1) como parte del Estándar de Firma Digital. Produce un resumen de 160 bits. SHA-1 se convirtió en el algoritmo hash dominante para certificados TLS/SSL, firma de código y almacenamiento de objetos de Git.

Familia SHA-2 (2001)

También diseñada por la NSA, SHA-2 es en realidad una familia de seis funciones: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 y SHA-512/256. SHA-256 y SHA-512 son las más utilizadas. Producen resúmenes de 256 y 512 bits respectivamente y permanecen seguros hoy en día.

SHA-3 / Keccak (2015)

Cuando las debilidades de SHA-1 se volvieron evidentes, el NIST organizó un concurso público (2007-2015) para encontrar un nuevo estándar hash completamente independiente del diseño SHA-2 de la NSA. El ganador fue Keccak, diseñado por Guido Bertoni, Joan Daemen, Michaël Peeters y Gilles Van Assche. A diferencia de SHA-2 que usa una construcción Merkle–Damgård, SHA-3 usa una construcción esponja, ofreciendo un perfil de seguridad fundamentalmente diferente.

BLAKE2 (2012)

BLAKE2 es una función hash criptográfica más rápida que MD5 mientras proporciona la seguridad de SHA-3. Fue diseñada por Jean-Philippe Aumasson, Samuel Neves, Zooko Wilcox-O'Hearn y Christian Winnerlein como mejora sobre BLAKE, que fue finalista en la competencia SHA-3. BLAKE2b está optimizado para plataformas de 64 bits; BLAKE2s para 32 bits.

3. Cómo Funciona SHA-256

SHA-256 usa la construcción Merkle–Damgård: el mensaje se divide en bloques de tamaño fijo, y se aplica una función de compresión de forma iterativa, alimentando la salida de un bloque como entrada al siguiente.

Paso 1: Relleno

El mensaje de entrada se rellena para que su longitud total sea múltiplo de 512 bits. Se añade un bit 1, seguido de ceros, seguido de la longitud original del mensaje como entero de 64 bits en formato big-endian.

Paso 2: Programación de Mensajes

Cada bloque de 512 bits se expande en 64 palabras de 32 bits usando un programa que mezcla y rota bits. Las palabras W[0] a W[15] provienen directamente del bloque de mensaje; las palabras W[16] a W[63] se calculan como:

W[i] = σ1(W[i-2]) + W[i-7] + σ0(W[i-15]) + W[i-16]

Donde σ0 y σ1 son operaciones específicas de rotación y desplazamiento de bits.

Paso 3: Compresión — 64 Rondas

SHA-256 mantiene 8 variables de trabajo (a hasta h), inicializadas con las partes fraccionarias de las raíces cuadradas de los primeros 8 números primos. Para cada una de las 64 rondas:

T1 = h + Σ1(e) + Ch(e,f,g) + K[i] + W[i]
T2 = Σ0(a) + Maj(a,b,c)
h = g; g = f; f = e; e = d + T1
d = c; c = b; b = a; a = T1 + T2

Las constantes de ronda K[i] son las partes fraccionarias de las raíces cúbicas de los primeros 64 primos — una elección de diseño que evita la crítica de "nada bajo la manga" al hacer las constantes públicamente verificables.

Paso 4: Salida

Después de procesar todos los bloques, las 8 variables de trabajo se suman a los valores hash iniciales para producir el resumen final de 256 bits. Este "feed-forward" garantiza que la salida de cada bloque depende de todos los bloques anteriores.

4. Por Qué MD5 y SHA-1 Están Rotos

Colisiones MD5 (2004)

En 2004, Xiaoyun Wang y sus colegas demostraron ataques de colisión prácticos contra MD5 — encontrando dos entradas diferentes que producen el mismo hash MD5. Para 2008, los investigadores usaron colisiones MD5 para falsificar un certificado SSL fraudulento de una CA real, demostrando un ataque del mundo real contra la infraestructura HTTPS.

El ataque usa sofisticado criptoanálisis diferencial y puede generar colisiones MD5 en segundos en hardware moderno.

SHA-1 SHAttered (2017)

El equipo Project Zero de Google y CWI Amsterdam produjeron la primera colisión SHA-1 práctica en 2017, denominada SHAttered. Generaron dos archivos PDF diferentes con hashes SHA-1 idénticos. El ataque requirió aproximadamente 9.2 × 10¹⁸ cálculos SHA-1 — equivalente a 6,500 años de tiempo de CPU simple — pero solo unos 110 años de tiempo de GPU, al alcance de estados-nación y grandes organizaciones.

Qué Significa en la Práctica

MD5 y SHA-1 NO son seguros para:

Firmas digitales
Huellas de certificados
Almacenamiento de contraseñas
Cualquier aplicación sensible a la seguridad

Todavía son aceptables para:

Sumas de verificación no criptográficas (verificar integridad de descarga por canal confiable)
Búsquedas en tablas hash
Deduplicación no relacionada con seguridad
Compatibilidad con sistemas heredados (con advertencias apropiadas)

5. Casos de Uso en el Mundo Real

Almacenamiento de Contraseñas

Nunca almacenes contraseñas en texto plano — ni siquiera como hashes simples. Si tu base de datos es filtrada, un atacante puede descifrar los hashes simples usando ataques de diccionario o tablas rainbow en horas o días.

El enfoque correcto usa una función hash lenta y con sal específicamente diseñada para contraseñas: bcrypt, scrypt o Argon2.

Verificación de Integridad de Archivos

Cuando descargas software, el desarrollador proporciona una suma de verificación SHA-256. Después de descargar, calculas el hash del archivo y comparas. Si coinciden, el archivo no fue corrompido ni alterado en tránsito.

sha256sum downloaded-file.tar.gz
# Compara con la suma de verificación publicada por el desarrollador

Firmas Digitales

Las funciones hash son fundamentales para las firmas digitales. En lugar de firmar un documento completo (que podría ser gigabytes), lo hasheas y firmas solo el hash. El receptor hashea el documento independientemente y verifica la firma contra ese hash.

Blockchain

Bitcoin usa SHA-256 dos veces (SHA-256d) para la minería de prueba de trabajo y para hashear bloques de transacciones. Los mineros deben encontrar una entrada (nonce) que, cuando se hashea, produce una salida con cierta cantidad de ceros iniciales — un proceso que requiere un esfuerzo computacional enorme y proporciona las garantías de seguridad de la blockchain.

Almacenamiento de Objetos Git

Git usa SHA-1 para hashear cada objeto de commit, árbol y blob. El hash sirve tanto como identificador del objeto como verificación de integridad. Git está migrando activamente a SHA-256 debido a las debilidades de SHA-1.

Deduplicación en Sistemas de Almacenamiento

Los sistemas de respaldo y el almacenamiento con direccionamiento por contenido (como IPFS) usan hashes para identificar contenido duplicado. Si dos archivos tienen el mismo hash, solo se almacenan una vez.

6. Cálculo de Hashes en la Práctica

JavaScript (Node.js)

const crypto = require('crypto');

// SHA-256
const sha256 = crypto.createHash('sha256')
  .update('Hello, World!')
  .digest('hex');
console.log(sha256);
// 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3

// MD5 (usar solo para propósitos no relacionados con seguridad)
const md5 = crypto.createHash('md5')
  .update('Hello, World!')
  .digest('hex');
console.log(md5);
// 65a8e27d8879283831b664bd8b7f0ad4

// SHA-512
const sha512 = crypto.createHash('sha512')
  .update('Hello, World!')
  .digest('hex');
console.log(sha512);

Python

import hashlib

# SHA-256
h = hashlib.sha256(b"Hello, World!").hexdigest()
print(h)
# 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3

# SHA-512
h512 = hashlib.sha512(b"Hello, World!").hexdigest()
print(h512)

# Múltiples algoritmos
for algo in ['md5', 'sha1', 'sha256', 'sha512']:
    h = hashlib.new(algo, b"Hello, World!").hexdigest()
    print(f"{algo}: {h}")

Bash / Terminal

# SHA-256
echo -n "Hello, World!" | sha256sum
# 315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3  -

# MD5
echo -n "Hello, World!" | md5sum
# 65a8e27d8879283831b664bd8b7f0ad4  -

# SHA-1
echo -n "Hello, World!" | sha1sum

# Hashear un archivo
sha256sum /path/to/file.iso

7. HMAC: Código de Autenticación de Mensajes Basado en Hash

Un hash simple verifica la integridad de los datos — te dice si los datos fueron corrompidos. Pero no verifica la autenticidad — no prueba quién creó los datos. Cualquiera puede calcular un hash.

HMAC (RFC 2104) resuelve esto combinando una clave secreta con la función hash:

HMAC(K, m) = hash((K' ⊕ opad) || hash((K' ⊕ ipad) || m))

Donde K' es la clave rellenada al tamaño del bloque, y opad/ipad son constantes de relleno específicas. Esta construcción es demostrablemente segura si la función hash subyacente es segura.

Usos Comunes

Autenticación de API: Las APIs REST usan HMAC-SHA256 para firmar solicitudes. El servidor y el cliente comparten una clave secreta. El cliente firma el cuerpo de la solicitud con la clave; el servidor verifica la firma.

Firmas JWT: Los JSON Web Tokens usan HMAC-SHA256 (HS256) para firmar el encabezado y el payload, asegurando que el token no fue alterado.

Verificación de Webhooks: GitHub, Stripe y muchos otros servicios firman los payloads de webhooks con HMAC-SHA256 para que los receptores puedan verificar que el payload es genuino.

Calculando HMAC

// Node.js
const crypto = require('crypto');

const hmac = crypto.createHmac('sha256', 'mi-clave-secreta')
  .update('mensaje a autenticar')
  .digest('hex');
console.log(hmac);

import hmac
import hashlib

key = b'my-secret-key'
message = b'message to authenticate'
sig = hmac.new(key, message, hashlib.sha256).hexdigest()
print(sig)

8. Tablas Rainbow y Sal (Salting)

¿Qué Son las Tablas Rainbow?

Una tabla rainbow es una base de datos precalculada que mapea valores hash conocidos de vuelta a sus entradas de texto plano originales. Si un atacante obtiene tu base de datos de hashes de contraseñas, no necesita descifrar cada hash individualmente — simplemente lo busca en la tabla.

Para MD5 y SHA-1, las tablas rainbow que cubren todas las contraseñas ASCII de hasta 8 caracteres han estado disponibles gratuitamente durante años. Sitios web como CrackStation mantienen bases de datos de miles de millones de mapeos hash-contraseña.

Cómo la Sal Derrota las Tablas Rainbow

Una sal es un valor aleatorio que se añade a la contraseña antes de hashearla:

hash(sal + contraseña) = hash_almacenado

La sal se almacena junto al hash (no necesita ser secreta). Como cada usuario obtiene una sal aleatoria única, el atacante no puede usar tablas precalculadas — necesitaría una tabla rainbow separada para cada valor de sal posible, lo cual es computacionalmente imposible.

bcrypt: Salado Automático y Lentitud Intencional

bcrypt fue diseñado en 1999 específicamente para el hash de contraseñas. Genera e incorpora automáticamente una sal aleatoria, e incluye un factor de costo que controla qué tan lento es el cálculo del hash:

const bcrypt = require('bcrypt');

// Hashear una contraseña (factor de costo 12 — toma ~250ms en hardware moderno)
const hash = await bcrypt.hash('contraseña-usuario', 12);

// Verificar
const isMatch = await bcrypt.compare('contraseña-usuario', hash);

El hash almacenado se ve así: $2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW

El prefijo $2b$12$ codifica la versión del algoritmo y el factor de costo — bcrypt maneja todo automáticamente.

9. Tabla de Comparación de Algoritmos

Algoritmo	Tamaño de Salida	Velocidad	Estado de Seguridad	Mejor Para
MD5	128 bits	Muy rápido	❌ Roto (colisiones)	Solo sumas de verificación no seguras
SHA-1	160 bits	Rápido	❌ Roto (SHAttered)	Solo sistemas heredados
SHA-256	256 bits	Rápido	✅ Seguro	Propósito general, TLS, firmas
SHA-512	512 bits	Rápido en 64 bits	✅ Seguro	Aplicaciones de alta seguridad
SHA-3/Keccak	Variable	Moderado	✅ Seguro	Alternativa a SHA-2
BLAKE2b	Variable	Muy rápido	✅ Seguro	Hash crítico para rendimiento
bcrypt	184 bits	Lento (intencional)	✅ Seguro	Almacenamiento de contraseñas
Argon2id	Variable	Lento (intencional)	✅ Seguro	Almacenamiento de contraseñas (recomendado)

10. Mejores Prácticas para el Hash de Contraseñas

Las contraseñas merecen un tratamiento especial porque son las llaves de las cuentas de usuario. Una base de datos de contraseñas comprometida puede ser devastadora. Sigue estas reglas sin excepción:

Regla 1: Nunca Almacenes Contraseñas en Texto Plano

Esto debería ser obvio pero sigue ocurriendo. En 2019, Facebook fue descubierto almacenando internamente cientos de millones de contraseñas en texto plano.

Regla 2: Nunca Uses Hashes Rápidos para Contraseñas

MD5, SHA-1, SHA-256 y SHA-512 son todos demasiado rápidos para el hash de contraseñas. Una GPU moderna puede calcular miles de millones de hashes SHA-256 por segundo, permitiendo ataques de fuerza bruta en horas.

Regla 3: Usa Algoritmos de Hash Diseñados Específicamente para Contraseñas

bcrypt (mínimo recomendado): Usa un factor de costo de 12 o superior. Ampliamente soportado, probado en batalla.

scrypt: Intensivo en memoria, haciéndolo resistente a ataques de GPU y ASIC. Costos de memoria y CPU configurables.

Argon2id (recomendado hoy): Ganador de la Competencia de Hashing de Contraseñas 2015. Argon2id es la variante recomendada ya que proporciona resistencia tanto contra ataques de canal lateral como contra ataques de compromiso tiempo-memoria. Configura con al menos:

Memoria: 64 MB
Iteraciones: 3
Paralelismo: 4

Regla 4: Usa una Sal Única por Contraseña

Incluso con bcrypt/scrypt/Argon2 (que incluyen salado automático), entiende por qué importa: las contraseñas idénticas deben producir hashes diferentes para que comprometer una no revele las demás.

Regla 5: Ajusta los Factores de Costo con el Tiempo

A medida que el hardware se vuelve más rápido, aumenta los factores de costo. Apunta a ~250-500ms para bcrypt. Rehashea contraseñas en el próximo inicio de sesión.

Regla 6: Considera el Uso de Pimienta (Pepper)

Una pimienta es un secreto del lado del servidor (a diferencia de la sal, no se almacena en la base de datos). Se añade a la contraseña antes de hashearla: hash(pimienta + sal + contraseña). Incluso si un atacante roba tu base de datos, no puede descifrar contraseñas sin la pimienta.

Conclusión

Las funciones hash criptográficas son fundamentales para la seguridad, integridad y confianza en toda internet. Entenderlas — desde sus propiedades matemáticas hasta sus vulnerabilidades prácticas — te permite construir sistemas que son genuinamente seguros.

Los puntos clave:

SHA-256 y SHA-512 son tus hashes de propósito general
MD5 y SHA-1 están rotos para usos criptográficos
Para contraseñas, siempre usa bcrypt, scrypt o Argon2
Usa HMAC cuando necesitas autenticación, no solo integridad
El salado derrota las tablas rainbow; bcrypt y Argon2 lo hacen automáticamente

Usa el Generador de Hash Tool3M para calcular rápidamente hashes SHA-256, SHA-512, MD5 y otros directamente en tu navegador — sin necesidad de instalación.