Cómo generar un hash SHA-256: online, línea de comandos y código, y por qué salen distintos

Qué es un hash SHA-256

SHA-256 es una de las funciones SHA-2 definidas por el NIST en FIPS 180-4. Lee la entrada como bytes, la procesa en bloques de 512 bits y produce un resumen de 256 bits. En hexadecimal cada byte son dos caracteres, así que el resultado tiene siempre 64 caracteres, tanto si la entrada era un byte como si era una imagen de disco de 4 GB.

Tres propiedades la hacen útil. Es determinista: los mismos bytes dan siempre el mismo hash. Cambiar un solo bit de la entrada cambia aproximadamente la mitad de los bits de la salida. Y no se conoce ninguna forma práctica de encontrar dos entradas con el mismo hash, ni de obtener la entrada a partir del hash.

La palabra clave es «bytes». SHA-256 nunca ve texto, sino los bytes que tu herramienta generó a partir del texto, y de ahí vienen casi todas las discrepancias.

SHA-256("")      = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
SHA-256("abc")   = ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-256("hello") = 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

Guarda estos valores de referencia. Calcular el hash de abc en una herramienta nueva y compararlo con el de arriba es la forma más rápida de comprobar que hace lo que crees.

SHA-256 online

Un generador SHA-256 online es lo más cómodo para comprobar un texto rápidamente. Elige uno que calcule el hash en el navegador sin enviar la entrada a un servidor, sobre todo si hashes datos internos o claves. Revisa también si la herramienta añade un salto de línea al final o recorta espacios, porque ambas cosas cambian el resultado. Para archivos grandes o para automatizar, la línea de comandos es más fiable.

En la línea de comandos: Linux, macOS y Windows

# Linux (GNU coreutils)
sha256sum archivo.iso
printf '%s' 'hello' | sha256sum

# macOS (shasum viene siempre; las versiones recientes incluyen sha256sum)
shasum -a 256 archivo.iso
printf '%s' 'hello' | shasum -a 256

# Donde haya OpenSSL
openssl dgst -sha256 archivo.iso

# Windows PowerShell: SHA256 es el algoritmo por defecto
Get-FileHash .\archivo.iso
Get-FileHash .\archivo.iso -Algorithm SHA256 | Select-Object -ExpandProperty Hash

# Windows cmd
certutil -hashfile archivo.iso SHA256

PowerShell y certutil muestran el hexadecimal en mayúsculas, y sha256sum en minúsculas. El hexadecimal no distingue mayúsculas, así que 2CF24D… y 2cf24d… son el mismo hash. Compáralos sin distinguir mayúsculas, o una descarga correcta parecerá corrupta.

Para comprobar una descarga contra un archivo de sumas publicado, deja que la herramienta compare. sha256sum -c lee líneas con el formato <hash> <archivo> e indica OK o FAILED para cada una.

sha256sum -c SHA256SUMS
# ubuntu.iso: OK

La trampa del salto de línea: por qué echo da otro hash

El error más habitual con SHA-256 no está en ninguna librería. echo añade un salto de línea, así que echo hello | sha256sum calcula el hash de seis bytes, hello\n, y no de cinco.

echo 'hello' | sha256sum
# 5891b5b522d5df086d0ff0b110fbd9d21bb4fc7163af34d08286a2e846f6be03   (hello + \n)

printf '%s' 'hello' | sha256sum
# 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824   (hello)

echo -n no es portable: algunos shells imprimen -n literalmente. En scripts, usa printf '%s'.

Los archivos tienen el mismo problema disfrazado. La mayoría de editores añaden un salto de línea al final al guardar, y Windows usa CRLF (\r\n) en lugar de LF, así que el mismo texto guardado en dos máquinas puede dar hashes distintos. La opción core.autocrlf de Git puede reescribir los finales de línea al hacer checkout, lo que explica una suma que pasa en un runner de CI con Linux y falla en un portátil con Windows.

En código: Python, Node.js, el navegador y PHP

Todos los lenguajes te obligan a elegir una codificación al calcular el hash de un texto. Usa UTF-8 salvo que un protocolo indique otra cosa, y calcula el hash de los archivos como bytes, no como texto.

import hashlib

hashlib.sha256('hello'.encode('utf-8')).hexdigest()

# Archivos grandes: por bloques, sin cargarlo todo en memoria (Python 3.11+)
with open('archivo.iso', 'rb') as f:
    print(hashlib.file_digest(f, 'sha256').hexdigest())

// Node.js
const { createHash } = require('node:crypto');
createHash('sha256').update('hello', 'utf8').digest('hex');

// Navegador (Web Crypto): asíncrono y solo en contexto seguro (HTTPS o localhost)
async function sha256Hex(texto) {
  const bytes = new TextEncoder().encode(texto);
  const digest = await crypto.subtle.digest('SHA-256', bytes);
  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('');
}

<?php
echo hash('sha256', 'hello');                          // 64 caracteres hexadecimales
echo hash_file('sha256', 'archivo.iso');
echo base64_encode(hash('sha256', 'hello', true));     // bytes -> Base64

crypto.subtle no está disponible en una página servida por HTTP desde un dominio real. Si un código funciona en localhost y falla en staging, revisa el protocolo antes de buscar un bug.

Hexadecimal, Base64 y bytes: el mismo hash

El resumen de 32 bytes puede escribirse de varias formas. El hexadecimal es lo habitual, pero la integridad de subrecursos (SRI) y algunas cabeceras HTTP usan Base64: hello es LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ= en Base64. Un error frecuente es codificar en Base64 la cadena hexadecimal en vez de los bytes, lo que da un valor de 88 caracteres que ningún verificador acepta. Codifica los bytes: digest() en Node, hash(…, true) en PHP, .digest() en lugar de .hexdigest() en Python.

Cuándo SHA-256 no es la herramienta adecuada

SHA-256 está diseñado para ser rápido, y justo por eso no debe usarse para guardar contraseñas: con una tabla filtrada, un atacante prueba miles de millones de candidatas por segundo. Usa un hash de contraseñas lento a propósito: Argon2id, scrypt o bcrypt.

Un hash simple tampoco autentica nada: cualquiera puede recalcular SHA-256(mensaje) tras modificar el mensaje. Si ambas partes comparten un secreto, por ejemplo para firmar webhooks, usa HMAC-SHA256, y evita SHA-256(secreto + mensaje), que es vulnerable a ataques de extensión de longitud.

import hmac, hashlib
firma = hmac.new(b'secreto-compartido', cuerpo_bytes, hashlib.sha256).hexdigest()
valida = hmac.compare_digest(firma, firma_recibida)   # comparación en tiempo constante

Fuentes y lecturas recomendadas

NIST FIPS 180-4 (Secure Hash Standard) define SHA-256. RFC 2104 define HMAC. El manual de GNU coreutils documenta sha256sum y su modo -c, MDN documenta SubtleCrypto.digest() y su requisito de contexto seguro, y la guía OWASP Password Storage Cheat Sheet explica por qué los hashes rápidos no sirven para contraseñas.

Frequently asked questions

¿Cómo genero un hash SHA-256 de un texto?

En Linux o macOS: `printf '%s' 'tu texto' | sha256sum` (o `shasum -a 256`). En Python, `hashlib.sha256(texto.encode()).hexdigest()`, y en Node.js, `createHash('sha256').update(texto).digest('hex')`. Evita `echo` sin `-n`, porque el salto de línea cambia el hash.

¿Por qué obtengo un hash SHA-256 distinto para el mismo texto?

Porque las herramientas procesan bytes distintos: un salto de línea final, finales de línea CRLF, un BOM de UTF-8 o otra codificación de texto. Calcula el hash de `abc` en ambas para comprobar que coinciden y revisa los bytes de la entrada.

¿Cuántos caracteres tiene un hash SHA-256?

64 caracteres en hexadecimal, que representan 32 bytes (256 bits). En Base64 son 44 caracteres, incluido un `=` de relleno.

¿Se puede descifrar un hash SHA-256?

No. Es una función de un solo sentido, no un cifrado, y no hay clave. Las entradas cortas o comunes pueden adivinarse por fuerza bruta, por eso las contraseñas necesitan algoritmos lentos.

¿Cómo compruebo el SHA-256 de un archivo en Windows?

En PowerShell, `Get-FileHash .\archivo.iso` (SHA-256 es el algoritmo por defecto). En cmd, `certutil -hashfile archivo.iso SHA256`. Compara sin distinguir mayúsculas.

¿Es seguro generar un hash SHA-256 online?

Sí, si la herramienta calcula el hash en tu navegador sin enviar el texto. No pegues contraseñas ni claves reales en servicios que suben la entrada a un servidor.