Generador de Hash SHA-256

¿Qué es el hash SHA-256?

SHA-256 (Secure Hash Algorithm de 256 bits) es una función hash criptográfica de la familia SHA-2, publicada por el NIST en 2001 como parte de FIPS 180-2 (actualizada en FIPS 180-4). Dado cualquier dato de entrada — un solo carácter, un archivo de varios gigabytes o una cadena vacía — SHA-256 produce un resumen fijo de 256 bits (32 bytes), representado convencionalmente como 64 caracteres hexadecimales. SHA-256 es la función hash más ampliamente utilizada en sistemas en producción hoy en día, y es la base de las cadenas de certificados TLS, el mecanismo de prueba de trabajo de Bitcoin, la Integridad de Subrecurso (SRI) y los flujos de firma de código.

SHA-256 es una función unidireccional: calcular un hash a partir de una entrada es rápido (cientos de megabytes por segundo en hardware moderno), pero revertir el proceso —encontrar una entrada que produzca un hash determinado— es computacionalmente inviable. Esta propiedad, llamada resistencia a preimagen, hace que SHA-256 sea adecuado para el hash de contraseñas (combinado con una sal y una función de derivación de clave), firmas digitales y verificación de integridad de datos. A diferencia de MD5 y SHA-1, no se ha demostrado ningún ataque de colisión o preimagen contra SHA-256 completo.

La familia SHA-2 incluye seis variantes: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 y SHA-512/256. SHA-256 opera con palabras de 32 bits y 64 rondas por bloque, optimizado para procesadores de 32 bits. SHA-512 usa palabras de 64 bits y 80 rondas, lo que puede ser más rápido en plataformas de 64 bits. Para la mayoría de las aplicaciones donde un resumen de 256 bits es suficiente, SHA-256 sigue siendo la recomendación predeterminada del NIST, el IETF y el CA/Browser Forum.

¿Por qué usar un generador SHA-256 online?

Generar un hash SHA-256 normalmente requiere un comando de terminal o unas pocas líneas de código. Esta herramienta basada en el navegador te permite calcular resúmenes SHA-256 sin instalar nada, cambiar de contexto ni escribir un script.

Casos de uso de SHA-256

Comparación de variantes de la familia SHA-2

SHA-256 pertenece a la familia SHA-2 definida en FIPS 180-4. Cada variante equilibra el tamaño del resumen, las características de rendimiento y el margen de seguridad. La tabla siguiente compara todas las variantes de SHA-2 que probablemente encuentres.

SHA-256 vs. SHA-1 vs. MD5 vs. SHA-3

La elección del algoritmo hash correcto depende de tus requisitos de seguridad y las restricciones de compatibilidad. SHA-256 ocupa el punto de equilibrio práctico: es seguro, está universalmente soportado (incluida la Web Crypto API) y es suficientemente rápido para la mayoría de las cargas de trabajo. La tabla comparativa siguiente cubre las propiedades más relevantes a la hora de seleccionar una función hash.

Cómo funciona SHA-256 internamente

SHA-256 procesa la entrada en bloques de 512 bits (64 bytes) mediante una construcción de Merkle–Damgård. El algoritmo inicializa ocho palabras de estado de 32 bits (H0–H7) derivadas de las partes fraccionarias de las raíces cuadradas de los primeros ocho números primos. Cada bloque pasa por 64 rondas de mezcla que utilizan operaciones bit a bit (AND, XOR, NOT, rotación a la derecha, desplazamiento a la derecha) y 64 constantes de ronda derivadas de las raíces cúbicas de los primeros 64 números primos.

El efecto avalancha garantiza que cambiar un solo bit en la entrada modifica aproximadamente el 50% de los bits de salida. Esta propiedad, combinada con una resistencia a colisiones de 2^128, es la razón por la que SHA-256 sigue siendo la recomendación base para aplicaciones sensibles a la seguridad en 2026.

Ejemplos de código SHA-256

SHA-256 está disponible de forma nativa en todos los lenguajes y runtimes principales. La Web Crypto API lo proporciona en los navegadores sin necesidad de ninguna librería. Los ejemplos siguientes muestran patrones de uso reales, incluyendo el manejo de entrada Unicode y el hash de archivos.

// Works in all modern browsers and Node.js 18+
async function sha256(text) {
  const data = new TextEncoder().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('')
}

await sha256('hello world')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha256').update('hello world').digest('hex')
// → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

import hashlib

# Basic SHA-256 hash
result = hashlib.sha256(b'hello world').hexdigest()
print(result)  # → "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"

# Hash a string (encode to bytes first)
text = 'café ☕'
hashlib.sha256(text.encode('utf-8')).hexdigest()
# → "3eb53e00aa1bb4b1e8aab1ab38e56e6b8fb0b20e1cf7e1d19f36e4fad2537445"

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha256()
    for chunk in iter(lambda: f.read(8192), b''):
        sha.update(chunk)
    print(sha.hexdigest())

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha256.Sum256(data)
    fmt.Printf("%x\n", hash)
    // → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
}

# Using sha256sum (Linux) or shasum (macOS)
echo -n "hello world" | sha256sum
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# macOS
echo -n "hello world" | shasum -a 256
# → b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9  -

# Verify a file checksum
echo "b94d27b...  myfile.bin" | sha256sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha256
# → SHA2-256(stdin)= b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

Preguntas frecuentes