Tecnología

Qué es un hash (MD5, SHA-1, SHA-256), para qué sirve y por qué no es cifrado

Qué hace una función hash, en qué se diferencian MD5, SHA-1 y SHA-256, cómo verificar una descarga en el terminal y en Node.js, y por qué no sirve para contraseñas.

Un hash es el resultado de pasar cualquier dato (un texto, un archivo, un disco entero) por una función hash: una operación matemática que devuelve siempre una cadena de longitud fija, como b221d9db… para la palabra hola con SHA-256. Es determinista (la misma entrada da siempre el mismo hash), cualquier cambio mínimo en la entrada cambia el resultado por completo y, con los algoritmos actuales, no es viable obtener la entrada a partir del hash ni fabricar dos entradas con el mismo. Por eso sirve para verificar la integridad de una descarga, detectar duplicados o firmar datos, y por eso no es cifrado: no hay clave ni forma de “deshacerlo”.

Este artículo explica cómo funciona, en qué se diferencian MD5, SHA-1 y SHA-256, cómo calcular y comparar hashes en el terminal, en Node.js y en el navegador, y los dos errores más comunes: usarlo como cifrado y usarlo tal cual para contraseñas.

Qué propiedades tiene un hash

Una función hash criptográfica cumple, según el estándar SHS del NIST, tres propiedades:

  1. Resistencia a la preimagen: dado un hash, no es viable encontrar una entrada que lo produzca.
  2. Resistencia a la segunda preimagen: dada una entrada, no es viable encontrar otra distinta con el mismo hash.
  3. Resistencia a colisiones: no es viable encontrar dos entradas cualesquiera con el mismo hash.

Además tiene efecto avalancha: cambiar una letra cambia el hash entero. Compara hola y Hola con SHA-256:

hola  → b221d9dbb083a7f33428d7c2a3c3198ae925614d70210e28716ccaa7cd4ddb79
Hola  → e633f4fc79badea1dc5db970cf397c8248bac47cc3acf9915ba60b5d76b0e88f

Y la cadena vacía también tiene hash (vale la pena reconocerlo, porque aparece cuando algo falla y se hashea “nada”):

""    → e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

MD5, SHA-1, SHA-256: cuál usar

Algoritmo Longitud Estado Para qué sigue valiendo
MD5 128 bits (32 hex) Roto para colisiones desde 2004; RFC 6151 desaconseja su uso donde importe la resistencia a colisiones Detectar duplicados o corrupción accidental de archivos; sumas de comprobación heredadas
SHA-1 160 bits (40 hex) Roto: Google y CWI publicaron la primera colisión práctica en 2017; NIST lo retira para firmas Identificadores internos de Git (que ya migra a SHA-256)
SHA-256 256 bits (64 hex) Recomendado (familia SHA-2) Verificación de descargas, firmas, certificados TLS, blockchains
SHA-512 512 bits (128 hex) Recomendado (SHA-2) Lo mismo que SHA-256; más rápido en CPU de 64 bits
SHA-3 variable Recomendado (estándar alternativo, 2015) Cuando se quiere independencia de la construcción de SHA-2

Regla práctica: para cualquier uso nuevo, SHA-256. MD5 y SHA-1 solo cuando compares con un hash que ya te dan en ese formato (muchos sitios de descarga aún publican MD5) y la amenaza sea corrupción accidental, no un atacante.

Los hashes de hola con los tres algoritmos, para que compruebes tu herramienta:

MD5     4d186321c1a7f0f354b297e8914ab240
SHA-1   99800b85d3383e3a2fb45eb7d0066a4879a9dad0
SHA-256 b221d9dbb083a7f33428d7c2a3c3198ae925614d70210e28716ccaa7cd4ddb79

Para qué se usa un hash

  • Verificar una descarga. El proveedor publica el SHA-256 del archivo; tú lo calculas en tu máquina y comparas. Si coincide, el archivo llegó íntegro y es el que publicaron (siempre que el hash lo hayas obtenido por un canal fiable, normalmente HTTPS o una firma).
  • Detectar cambios y duplicados. Sistemas de copia de seguridad, deduplicación y sincronización comparan hashes en lugar de archivos enteros.
  • Identificar contenido. Git identifica cada commit y cada archivo por su hash; las CDN usan hashes en los nombres de archivo (app.3f9a1c.js) para invalidar la caché solo cuando el contenido cambia.
  • Firmas digitales y certificados. Lo que se firma no es el documento, sino su hash.
  • HMAC y tokens. Un JWT con HS256 se firma con un HMAC-SHA256: un hash combinado con una clave secreta.

Cómo calcular un hash

En el terminal

# Linux (coreutils)
sha256sum archivo.iso
md5sum archivo.iso

# macOS
shasum -a 256 archivo.iso
md5 archivo.iso

# Windows (PowerShell)
Get-FileHash archivo.iso -Algorithm SHA256

Para comparar con el hash publicado sin leer 64 caracteres a ojo, guarda el oficial en un archivo y deja que la herramienta compare:

echo "b221d9db…  archivo.iso" > archivo.iso.sha256
sha256sum -c archivo.iso.sha256
# archivo.iso: La suma coincide

En Node.js

import { createHash } from 'node:crypto';
import { createReadStream } from 'node:fs';

// Texto
createHash('sha256').update('hola').digest('hex');
// 'b221d9dbb083a7f33428d7c2a3c3198ae925614d70210e28716ccaa7cd4ddb79'

// Archivo grande, sin cargarlo entero en memoria
const hash = createHash('sha256');
for await (const chunk of createReadStream('archivo.iso')) hash.update(chunk);
console.log(hash.digest('hex'));

En el navegador

La API SubtleCrypto calcula SHA-256 sin librerías (no incluye MD5, precisamente porque está roto):

async function sha256(text) {
  const bytes = new TextEncoder().encode(text);
  const buffer = await crypto.subtle.digest('SHA-256', bytes);
  return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, '0')).join('');
}
await sha256('hola'); // 'b221d9db…'

Si solo necesitas comprobar un archivo o un texto una vez, el generador de hashes de AIMRAN Tools calcula MD5, SHA-1, SHA-256 y SHA-512 en el navegador, también de archivos arrastrados, sin subir nada a ningún servidor.

Los dos errores más comunes

1. Confundir hash con cifrado

Cifrar es reversible con una clave; hashear no es reversible por diseño. Un hash no “protege” un dato: si el dato tiene pocas posibilidades (un DNI, un teléfono, una contraseña corta), cualquiera puede hashear todas las opciones y compararlas. Hashear un correo electrónico no lo anonimiza.

2. Guardar contraseñas con un hash rápido

SHA-256 está diseñado para ser rápido, y eso es justo lo contrario de lo que quieres al guardar contraseñas: una GPU calcula miles de millones de SHA-256 por segundo. La guía de OWASP recomienda funciones diseñadas para ser lentas y configurables: Argon2id (primera opción), scrypt o bcrypt, siempre con salt único por usuario (las tres lo incorporan). Un sha256(contraseña) a secas, incluso con salt, se considera inadecuado hoy.

Conclusión

Un hash es una huella de longitud fija: determinista, sensible a cualquier cambio y no reversible. Úsalo con SHA-256 para verificar descargas, detectar cambios e identificar contenido; compara siempre contra un hash obtenido por un canal fiable; recuerda que MD5 y SHA-1 solo valen frente a errores accidentales, no frente a atacantes; y para contraseñas, olvida los hashes rápidos y usa Argon2id, scrypt o bcrypt.

Fuentes y referencias

  1. FIPS 180-4: Secure Hash Standard (NIST) csrc.nist.gov
  2. NIST: Transitioning the Use of Cryptographic Algorithms and Key Lengths (SP 800-131A Rev. 2) csrc.nist.gov
  3. RFC 6151: Updated Security Considerations for the MD5 Message-Digest and the HMAC-MD5 Algorithms rfc-editor.org
  4. Google Security Blog: Announcing the first SHA1 collision (2017) security.googleblog.com
  5. OWASP Cheat Sheet: Password Storage cheatsheetseries.owasp.org
  6. MDN: SubtleCrypto.digest() developer.mozilla.org

Herramientas relacionadas

Herramientas gratuitas de AIMRAN Tools que funcionan en tu navegador, sin registro.

Ver todas las herramientas
Artículos de Tecnología