MD5 vs SHA-256 vs SHA-512 — Funciones Hash Explicadas

Las funciones hash están en todas partes en el desarrollo de software: verificación de integridad de archivos, almacenamiento de contraseñas, firmas digitales, autenticación de API, claves de caché, deduplicación. Sin embargo, la mayoría de los desarrolladores las usan como cajas negras — introduces una cadena y obtienes un digest hexadecimal de longitud fija. Los detalles de qué función hash usar, y cuál evitar, resultan ser muy importantes.

MD5 está roto. SHA-1 está obsoleto. SHA-256 y SHA-512 son actualmente seguros. SHA-3 existe si quieres prepararte para el futuro. Pero "roto" no significa lo mismo en todos los contextos — MD5 está bien para algunos casos de uso y es desastroso para otros. Esta guía explica las propiedades que importan, cómo cada función las cumple, y te da un marco de decisión claro para elegir el hash correcto en 2026.

Qué Hace Realmente una Función Hash

Una función hash criptográfica mapea una entrada de longitud arbitraria a una salida de longitud fija (el digest o hash). Tres propiedades definen una función hash criptográficamente segura:

• Resistencia a la preimagen — dado un hash h, debe ser computacionalmente inviable encontrar cualquier entrada m tal que hash(m) = h. Esta es la propiedad "unidireccional".
• Resistencia a la segunda preimagen — dada una entrada m1, debe ser inviable encontrar una entrada diferente m2 tal que hash(m1) = hash(m2).
• Resistencia a colisiones — debe ser inviable encontrar cualquier par de entradas distintas m1 y m2 tal que hash(m1) = hash(m2).

Una función que falla cualquiera de estas propiedades se considera rota para uso criptográfico. Ten en cuenta que "inviable" tiene un significado específico aquí: no significa matemáticamente imposible, significa que requiere más cómputo del que es práctico con el hardware actual o previsible.

Además, las funciones hash criptográficas presentan el efecto avalancha: cambiar un solo bit en la entrada produce una salida que difiere en aproximadamente la mitad de sus bits. Esto garantiza que entradas similares produzcan digests completamente diferentes.

Entrada: "hello"
MD5:     5d41402abc4b2a76b9719d911017c592  (128-bit / 32 caracteres hex)

Entrada: "Hello"
MD5:     8b1a9953c4611296a827abf8c47804d7  (un cambio de carácter = salida completamente diferente)

MD5 — Rápido, Ubicuo y Roto

Historia y diseño

MD5 (Message Digest 5) fue diseñado por Ron Rivest en 1991 y produce un digest de 128 bits (16 bytes). Durante la mayor parte de los años 90 fue la opción estándar para la verificación de integridad de archivos, la firma de certificados y el hashing de contraseñas. Es extremadamente rápido — una CPU moderna puede calcular decenas de millones de hashes MD5 por segundo, y una GPU puede calcular miles de millones.

Por qué MD5 está roto

En 2004, Xiaoyun Wang y sus colaboradores demostraron un ataque de colisión práctico contra MD5 — dos archivos diferentes que producen el mismo hash MD5. El ataque se ejecuta en minutos en hardware de consumo. En 2008, los investigadores crearon un certificado CA falso usando una colisión MD5, demostrando que la infraestructura PKI del mundo real era vulnerable. En 2012, el malware Flame usó una colisión MD5 para falsificar un certificado de firma de código de Microsoft.

NIST deprecó oficialmente MD5 para la mayoría de los usos criptográficos. Las autoridades de certificación dejaron de emitir certificados firmados con MD5 en 2009. Los fabricantes de navegadores eliminaron el soporte para firmas de certificados MD5 alrededor de 2011.

Cuándo MD5 todavía es aceptable

MD5 no es universalmente inútil. Para checksums sin relevancia de seguridad — detectar corrupción accidental de datos en transferencias de archivos, direccionamiento basado en contenido en un sistema de caché donde el atacante no puede influir en las entradas, o generar identificadores únicos en un sistema interno cerrado — MD5 sigue siendo adecuado. La prueba clave: si un atacante puede beneficiarse de crear una colisión, no uses MD5. Si solo importa la corrupción accidental, MD5 está bien.

• Seguro: deduplicación interna, claves de caché, detección de cambios en archivos sin relevancia de seguridad
• Inseguro: certificados, firmas digitales, hashing de contraseñas, verificación de autenticidad de archivos, tokens de seguridad

SHA-1 — Obsoleto, Pero No Muerto del Todo

SHA-1 produce un digest de 160 bits y fue el sucesor de MD5. Se mantuvo como estándar para la firma de certificados y de código durante la mayor parte de los años 2000. En 2017, el ataque SHAttered demostró la primera colisión SHA-1 práctica, produciendo dos archivos PDF diferentes con hashes SHA-1 idénticos usando aproximadamente 110 años-GPU de cómputo — caro pero dentro del presupuesto de los estados nacionales y cada vez más accesible.

SHA-1 está deprecado por NIST y todas las principales autoridades de certificación. No debe usarse para certificados, firma de código, ni ninguna nueva aplicación sensible a la seguridad. Algunos sistemas heredados todavía usan SHA-1 internamente, pero se recomienda encarecidamente migrar a SHA-256. Git todavía usa SHA-1 para el direccionamiento de objetos (aunque la transición a SHA-256 está en curso), pero esto está siendo eliminado progresivamente.

SHA-256 — El Estándar Actual

SHA-256 forma parte de la familia SHA-2, diseñada por la NSA y estandarizada por NIST en FIPS 180-4. Produce un digest de 256 bits (32 bytes). SHA-256 ha sido analizado intensivamente desde su publicación en 2001 y no se ha encontrado ningún ataque práctico. Es el estándar de facto para:

• Certificados TLS (esencialmente todos los certificados emitidos hoy usan SHA-256)
• Firma de código (Windows Authenticode, notarización de Apple, JARs)
• HMAC-SHA256 para autenticación de API (AWS Signature v4, verificación de webhooks de GitHub)
• Firmas de tokens JWT (HS256 y RS256 usan SHA-256 internamente)
• IDs de transacciones blockchain (Bitcoin usa doble-SHA256)
• Verificación de integridad de archivos en gestores de paquetes (npm, pip, apt)

Entrada:  "hello"
SHA-256:  2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
          (256-bit / 64 caracteres hex)

SHA-512:  9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d
          99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
          (512-bit / 128 caracteres hex)

Rendimiento de SHA-256

SHA-256 usa operaciones de palabras de 32 bits internamente. En hardware de 32 bits o CPUs antiguas sin aceleración por hardware, es notablemente más lento que MD5. En CPUs de 64 bits modernas con extensiones SHA (Intel Goldmont+, AMD Zen+, Apple Silicon, ARM Cortex-A57+), SHA-256 está acelerado por hardware y es extremadamente rápido — a menudo acercándose a las velocidades de MD5. La mayoría de los entornos de servidor tienen aceleración por hardware, por lo que en la práctica SHA-256 es suficientemente rápido para casi todas las aplicaciones.

SHA-512 — Más Amplio, A Veces Más Rápido

SHA-512 produce un digest de 512 bits (64 bytes) usando operaciones de palabras de 64 bits internamente. En hardware de 64 bits sin extensiones SHA, SHA-512 puede ser en realidad más rápido que SHA-256 porque sus operaciones de 64 bits hacen mejor uso del ancho de los registros modernos. En hardware con extensiones SHA, SHA-256 es típicamente más rápido porque las extensiones están específicamente optimizadas para SHA-256.

SHA-512 proporciona un mayor margen de seguridad — 256 bits de resistencia a colisiones frente a 128 bits de SHA-256. Para la mayoría de los modelos de amenaza actuales, la resistencia a colisiones de 128 bits de SHA-256 es más que suficiente (romperla requeriría aproximadamente 2^128 operaciones). SHA-512 es apropiado cuando:

• Apuntas a servidores de 64 bits y quieres máximo rendimiento sin extensiones por hardware
• Necesitas digests más largos como material clave para otras operaciones criptográficas
• Quieres un margen de seguridad adicional para datos que deben permanecer protegidos durante décadas
• Estás implementando protocolos que específicamente requieren SHA-512 (por ejemplo, algunos conjuntos de cifrado TLS)

SHA-384 y SHA-512/256

SHA-384 es una versión truncada de SHA-512 que produce 384 bits — útil cuando quieres las operaciones internas de 64 bits de SHA-512 pero necesitas una salida más corta. SHA-512/256 es otra variante truncada que produce 256 bits de salida usando el cómputo interno de SHA-512. SHA-512/256 es resistente a los ataques de extensión de longitud que afectan a SHA-256, lo que lo hace útil en contextos donde la extensión de longitud es una preocupación (aunque HMAC ya mitiga esto en la mayoría de los escenarios prácticos).

SHA-3 — Arquitectura Diferente, Preparado para el Futuro

SHA-3 (estandarizado en NIST FIPS 202, 2015) usa la construcción de esponja Keccak — un diseño fundamentalmente diferente de la estructura Merkle-Damgård de SHA-2. Esto es importante porque cualquier debilidad futura descubierta en el diseño Merkle-Damgård afectaría simultáneamente a MD5, SHA-1 y SHA-2, mientras que SHA-3 permanecería sin verse afectado.

SHA-3 es actualmente seguro y es la opción correcta para nuevos sistemas que necesitan garantías a largo plazo o que quieren cubrirse ante futuras debilidades de SHA-2. Es más lento que SHA-256 en implementaciones de software puro. Donde SHA-3 destaca es en implementaciones de hardware — su diseño es muy eficiente en silicio. SHA-3-256 y SHA-3-512 producen los mismos tamaños de digest que sus homólogos SHA-2.

Tabla Comparativa

Hashing de Contraseñas: Un Problema Completamente Diferente

Esto merece su propia sección porque es uno de los errores más comunes que cometen los desarrolladores. SHA-256 es la herramienta correcta para verificaciones de integridad de archivos, firma de API y verificación de certificados. Es la herramienta incorrecta para hashear contraseñas, y usarla para ese propósito causa incidentes de seguridad reales.

El problema es la velocidad. SHA-256 está diseñado para ser rápido — una GPU moderna puede calcular miles de millones de hashes SHA-256 por segundo. Un atacante que obtiene tu base de datos de contraseñas hasheadas puede intentar miles de millones de suposiciones de contraseña por segundo. Incluso una contraseña larga y aleatoria puede romperse rápidamente si el hash es rápido.

// NUNCA hagas esto con contraseñas
const hash = crypto.createHash('sha256').update(password).digest('hex');

// Usa bcrypt, scrypt o Argon2 para contraseñas
const bcrypt = require('bcrypt');
const hash = await bcrypt.hash(password, 12);  // factor de coste 12

La herramienta Bcrypt Test te permite hashear y verificar contraseñas bcrypt en el navegador. Para entender los factores de coste de bcrypt y su tiempo de cómputo, es una referencia útil al configurar el factor de trabajo de tu aplicación.

HMAC: Añadiendo Autenticación a un Hash

Un hash simple no demuestra nada sobre quién lo calculó — cualquiera que tenga los datos puede calcular el mismo hash SHA-256. HMAC (Código de Autenticación de Mensajes Basado en Hash) añade una clave secreta al cómputo, produciendo una etiqueta que solo puede reproducir alguien que conozca la clave. HMAC-SHA256 es el estándar para:

• Verificación de firmas de webhooks (GitHub, Stripe, Shopify usan todos HMAC-SHA256)
• AWS Signature Version 4 (firma de solicitudes)
• Tokens JWT HS256 (HMAC-SHA256 del encabezado + payload)
• Integridad de cookies (firmar cookies de sesión para prevenir manipulaciones)

const crypto = require('crypto');

// Firmar un mensaje con HMAC-SHA256
const mac = crypto
  .createHmac('sha256', secretKey)
  .update(message)
  .digest('hex');

// Verificar: comparar en tiempo constante (previene ataques de temporización)
const isValid = crypto.timingSafeEqual(
  Buffer.from(mac, 'hex'),
  Buffer.from(received, 'hex')
);

Observa el uso de timingSafeEqual para la comparación. Comparar valores MAC con una comprobación de igualdad de cadenas regular filtra información de temporización que puede explotarse en un ataque de temporización. Usa siempre una función de comparación en tiempo constante al verificar MACs. Usa el Generador de HMAC para calcular valores HMAC-SHA256 para pruebas y depuración sin escribir código.

Recomendaciones para Casos Reales

Integridad general de archivos (checksums)

Usa SHA-256. Es el estándar para la verificación de paquetes (lockfiles de npm, hashes de requirements de pip, capas de imágenes Docker). La herramienta SHA-256 Hash calcula digests SHA-256 en tu navegador para texto de entrada o valores de cadena. Para checksums rápidos sin relevancia de seguridad donde la velocidad es crítica y confías en la fuente, MD5 sigue siendo aceptable, pero SHA-256 es preferible en cualquier contexto compartido o automatizado.

Certificados TLS y firma de código

SHA-256 es el estándar requerido. Todas las autoridades de certificación emiten certificados SHA-256. Nunca uses MD5 o SHA-1 para nuevos certificados — serán rechazados por los navegadores y sistemas operativos modernos.

Autenticación de API

Usa HMAC-SHA256. Es el estándar establecido, bien soportado en todos los lenguajes, y el algoritmo esperado por la mayoría de la documentación de seguridad de API. Calcula digests con la herramienta MD5 Hash o SHA-256 Hash para comparaciones rápidas, y genera firmas HMAC con el Generador de HMAC.

Hashing de contraseñas

Usa bcrypt (factor de coste 12+), scrypt o Argon2id. Nunca uses MD5, SHA-1, SHA-256 o SHA-512 directamente para contraseñas, ni siquiera con salting. La herramienta Bcrypt Test puede ayudarte a verificar hashes bcrypt durante el desarrollo.

Datos de larga duración que requieren décadas de seguridad

Prefiere SHA-512 o SHA-3-256. El mayor tamaño del digest proporciona margen adicional frente a los avances en criptoanálisis. NIST recomienda SHA-512 y SHA-3 para aplicaciones que requieren seguridad a largo plazo. Consulta la guía oficial en NIST FIPS 180-4 para la especificación autoritativa de los algoritmos SHA-2.

Nuevos sistemas sin restricciones heredadas

SHA-256 para uso general. Argon2id para contraseñas. HMAC-SHA256 para códigos de autenticación. Si quieres prepararte para el futuro y puedes aceptar un rendimiento ligeramente inferior, SHA-3-256 es una sólida alternativa a SHA-256 para hashing de propósito general.