Por qué importan las funciones hash

Cada vez que un usuario crea una cuenta, tu sistema se enfrenta a una pregunta fundamental: ¿cómo guardas su contraseña? La respuesta ingenua, guardarla en texto plano, ha causado algunas de las mayores filtraciones de datos de la historia. Una función hash es la base de la respuesta correcta.

Hashing, sal y HMAC: guía para desarrolladores sobre el tratamiento seguro de datos

Una función hash criptográfica transforma una entrada de cualquier longitud en una salida de longitud fija (el “digest” o “hash”) con tres propiedades críticas:

  1. Determinista: la misma entrada produce siempre la misma salida.
  2. Unidireccional: dada la salida, es computacionalmente inviable recuperar la entrada.
  3. Efecto avalancha: un cambio diminuto en la entrada (incluso un solo bit) cambia por completo la salida.

Estas propiedades permiten guardar solo el hash, y no la contraseña. Cuando un usuario inicia sesión, calculas el hash de lo que introduce y lo comparas con el hash guardado. Si coinciden, la contraseña es correcta, sin que llegues a conocer nunca la contraseña original.


Comparación de algoritmos hash

No todos los algoritmos hash son iguales a efectos de seguridad.

Algoritmo Tamaño de salida Velocidad ¿Para contraseñas? Estado actual
MD5 128 bits Muy rápido Nunca Roto: se han encontrado colisiones
SHA-1 160 bits Rápido Nunca Obsoleto: se han encontrado colisiones
SHA-256 256 bits Rápido No (demasiado rápido) Seguro para comprobar integridad
SHA-512 512 bits Rápido No (demasiado rápido) Seguro para comprobar integridad
bcrypt 192 bits Lento (ajustable) Sí Recomendado
scrypt Variable Lento + uso intensivo de memoria Sí Recomendado
Argon2id Variable Lento + uso intensivo de memoria Sí La mejor opción actual

Por qué “demasiado rápido” es un problema para el hash de contraseñas

SHA-256 está diseñado para la velocidad: puede calcular miles de millones de hashes por segundo con hardware moderno. Eso es estupendo para comprobar la integridad de archivos, pero pésimo para guardar contraseñas: un atacante que robe tu base de datos puede probar miles de millones de intentos por segundo.

Los algoritmos de hash de contraseñas como bcrypt y Argon2id son lentos a propósito. Incorporan un factor de coste (también llamado factor de trabajo o número de iteraciones) que controla cuánto cálculo requiere cada hash. A medida que el hardware se vuelve más rápido, aumentas el factor de coste para mantener la misma seguridad efectiva.

SHA-256: ~1000 millones de hashes/segundo (GPU)
bcrypt (coste 12): ~200 hashes/segundo — 5 millones de veces más lento
Argon2id: configurable, se puede hacer aún más lento

La sal: por qué es imprescindible

Incluso con un algoritmo lento hay otro ataque: las rainbow tables, bases de datos precalculadas que asocian contraseñas comunes con sus hashes. Si dos usuarios tienen la contraseña “hunter2”, sus hashes bcrypt serán distintos, pero sin sal sus hashes SHA-256 serían idénticos, lo que revelaría que comparten contraseña.

Una sal es un valor aleatorio, único para cada usuario, que se combina con la contraseña antes de calcular el hash. La sal se guarda en texto plano junto al hash (no es un secreto: su finalidad es la aleatoriedad, no la confidencialidad).

Usuario A: sal = "x7kP9mQ3", contraseña = "hunter2"
  → hash("x7kP9mQ3hunter2") → hash único A

Usuario B: sal = "r2Tz8wN5", contraseña = "hunter2"
  → hash("r2Tz8wN5hunter2") → hash único B (completamente distinto)

Las bibliotecas modernas de hash de contraseñas generan la sal automáticamente. No deberías implementar nunca tu propia lógica de sal.

Implementación práctica

// JavaScript / Node.js — con bcrypt
import bcrypt from 'bcrypt';

// Calcular el hash de una contraseña (la sal se genera e incrusta automáticamente)
const hash = await bcrypt.hash('myPassword123', 12); // 12 = factor de coste
// "$2b$12$..." — la cadena incluye el algoritmo, el coste, la sal y el hash

// Verificar durante el inicio de sesión
const isValid = await bcrypt.compare('myPassword123', hash); // true
const isWrong = await bcrypt.compare('wrongPassword', hash); // false
# Python — con argon2-cffi (Argon2id)
from argon2 import PasswordHasher

ph = PasswordHasher(
    time_cost=3,     # iteraciones
    memory_cost=65536, # 64 MB
    parallelism=2,
)

hash = ph.hash('myPassword123')  # incluye la sal automáticamente

try:
    ph.verify(hash, 'myPassword123')  # devuelve True o lanza una excepción
    print("Valid password")
except Exception:
    print("Invalid password")
// Go — con golang.org/x/crypto/bcrypt
import "golang.org/x/crypto/bcrypt"

// Hash
hash, err := bcrypt.GenerateFromPassword([]byte("myPassword123"), 12)

// Verificar
err = bcrypt.CompareHashAndPassword(hash, []byte("myPassword123"))
if err == nil {
    // válida
}

HMAC: verificación de integridad autenticada

Un hash simple responde: “¿Son estos datos los mismos que antes?”
Un HMAC (Hash-based Message Authentication Code) responde: “¿Están estos datos sin modificar Y proceden de alguien que conoce la clave secreta?”

HMAC combina una función hash con una clave secreta compartida:

HMAC(key, message) = hash(key ⊕ opad || hash(key ⊕ ipad || message))

Si no conoces la clave, no puedes producir un HMAC válido, aunque puedas leer y modificar el mensaje.

Casos de uso habituales

Verificación de la firma de webhooks: servicios como Stripe y GitHub firman los payloads de los webhooks con HMAC-SHA256, lo que te permite verificar que la petición viene de ellos:

import crypto from 'crypto';

function verifyWebhookSignature(payload, signature, secret) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  
  // Usa timingSafeEqual para evitar ataques de temporización
  return crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(expected, 'hex')
  );
}

Firma de peticiones de API: algunas API exigen firmar los parámetros de la petición con HMAC para evitar manipulaciones y ataques de repetición.

Integridad de las cookies: firma los valores de las cookies para que se pueda detectar cualquier manipulación (aunque los datos sensibles también deben cifrarse).


SHA-256 para la integridad de los datos (no para contraseñas)

Para usos que no son contraseñas, como verificar la integridad de archivos, generar huellas de contenido o crear sumas de comprobación, SHA-256 es la opción adecuada. Es rápido, está ampliamente soportado y produce una cadena hexadecimal de 64 caracteres.

// Navegador — con la Web Crypto API
async function sha256(text) {
  const encoder = new TextEncoder();
  const data = encoder.encode(text);
  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
}

const hash = await sha256('Hello, World!');
// "dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986d"
import hashlib

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

# SHA-512 (más fuerte, salida más grande)
h512 = hashlib.sha512(b"Hello, World!").hexdigest()

Errores de seguridad habituales que debes evitar

1. Usar MD5 o SHA-1 para contraseñas

Estos algoritmos están rotos criptográficamente y se pueden revertir con rainbow tables. No los uses para nada que sea sensible a la seguridad.

2. Inventar tu propia criptografía

La implementación de funciones hash está llena de trampas sutiles (ataques de temporización, problemas de relleno, errores de derivación de claves). Usa siempre bibliotecas bien auditadas.

3. Olvidar timingSafeEqual en las comparaciones

Una comparación ingenua de cadenas (===) termina en cuanto encuentra la primera diferencia. Eso crea un canal lateral de temporización: un atacante puede medir cuánto tarda la comparación para adivinar los caracteres correctos uno a uno. Usa siempre una comparación de tiempo constante para valores sensibles a la seguridad.

4. Reutilizar sales

Si usas la misma sal para todos los usuarios, los usuarios con la misma contraseña tendrán el mismo hash. Cada usuario debe tener una sal única y generada de forma aleatoria.

5. Guardar secretos en el código

Las claves secretas que se usan para HMAC deben proceder de variables de entorno o de un gestor de secretos, y nunca estar escritas en el código fuente.


Novedades de noviembre de 2026

  • Ahora se admiten MD5, SHA-3 (224/256/384/512) y CRC32, en JavaScript puro en el navegador. MD5 y SHA-3 también sirven para HMAC (CRC32 no tiene HMAC).
  • MD5 y CRC32 permiten construir colisiones, así que úsalos solo para comprobar archivos y por compatibilidad con APIs antiguas, nunca para detectar manipulación ni como criptografía.

Pruébalo en la herramienta

Preguntas frecuentes

¿Qué diferencia hay entre hashing y cifrado?

El hashing es unidireccional: no se pueden recuperar los datos originales a partir de un hash. El cifrado es bidireccional: con la clave se puede descifrar el texto cifrado para recuperar los datos originales. Usa hashing para las contraseñas (nunca necesitas “ver” el original). Usa cifrado para los datos que necesitas recuperar, como números de tarjetas de crédito o información personal.

¿Cómo elijo un factor de coste de bcrypt?

El factor de coste debe fijarse de forma que calcular el hash tarde unos 100–300 milisegundos en tu hardware de producción. Empieza con un coste de 12 y mide: bcrypt.hash('test', cost). Aumenta el coste a medida que el hardware mejore con el tiempo.

¿Debo usar SHA-256 o SHA-3?

SHA-256 (de la familia SHA-2) es seguro y sigue siendo la opción más extendida. SHA-3 (Keccak) tiene un diseño fundamentalmente distinto y también es seguro, pero tiene menos soporte en bibliotecas. SHA-256 es la opción práctica por defecto, salvo que tengas requisitos específicos de cumplimiento o compatibilidad que exijan SHA-3.

¿Puedo usar hashing para datos sensibles que no sean contraseñas?

Para los datos que necesitas recuperar (números de la seguridad social, números de tarjetas de pago), usa cifrado, no hashing. Para los datos que solo necesitas verificar (contraseñas, huellas de documentos), usa hashing. Para los tokens de API que guardas en el servidor, es aceptable el hashing con SHA-256 (sin bcrypt), ya que los tokens de API ya son valores aleatorios de alta entropía.

¿Qué es una colisión de hash?

Una colisión se produce cuando dos entradas distintas producen la misma salida de hash. En un hash de 256 bits, encontrar una colisión por fuerza bruta es computacionalmente imposible. En cambio, MD5 y SHA-1 tienen debilidades conocidas que permiten fabricar colisiones, y por eso ya no se consideran seguros.