Generador de Hash SHA-1 (Legado de 160 bits)

¿Qué es SHA-1?

// Hash text using Web Crypto API (SHA-1 — legacy use only)
async function sha1(text) {
  const data = new TextEncoder().encode(text);
  const hash = await crypto.subtle.digest('SHA-1', data);
  return Array.from(new Uint8Array(hash))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

await sha1('Hello, World!');
// → '0a0a9f2a6772942557ab5355d76af442f8f65e01'
// ⚠️ SHA-1 is broken — use SHA-256 for new work.

Ejemplos de SHA-1

tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904
author A Dev <dev@example.com> 1716854400 +0000
committer A Dev <dev@example.com> 1716854400 +0000

Initial commit

-----BEGIN CERTIFICATE-----
MIIDXTCCAkWgAwIBAgIJAKlL...
-----END CERTIFICATE-----

node-v0.12.7-linux-x64.tar.gz

(Pega el contenido del archivo shattered-1.pdf de Google/CWI en la pestaña Archivo)

Cómo generar hashes SHA-1

1. 1

   Pega texto o suelta un archivo

   Selecciona la pestaña Texto y pega cualquier cadena — un mensaje de commit, el cuerpo de un certificado o una entrada de checksum heredado — en el área de entrada. El hash SHA-1 se actualiza mientras escribes. Para archivos, cambia a la pestaña Archivo y arrastra cualquier archivo a la zona de soltar; el navegador lo hashea localmente sin ninguna subida.

2. 2

   Copia el hash de 40 caracteres

   Haz clic en el botón Copiar junto a la salida del hash. La cadena hexadecimal completa de 40 caracteres en minúsculas va a tu portapapeles. Usa la opción Mayúsculas si tu sistema heredado espera hexadecimal en mayúsculas — algunas herramientas antiguas y APIs de Windows usan mayúsculas por defecto.

3. 3

   Compara contra una huella heredada

   Cambia a la pestaña Comparar y pega dos hashes SHA-1 lado a lado para confirmar que coinciden. Útil para validar un checksum de editor heredado, auditar un repositorio Git espejo, o comprobar una huella de certificado TLS antiguo de un documento anterior a la adopción de SHA-256.

Detalles técnicos

Algoritmo: construcción Merkle-Damgård, 80 rondas

SHA-1 procesa la entrada en bloques de 512 bits (64 bytes), aplicando 80 rondas de operaciones bit a bit agrupadas en cuatro etapas de 20 rondas cada una, con una función lógica diferente (Ch, Paridad, Maj, Paridad) y una constante aditiva derivada de las raíces cuadradas de enteros pequeños. El estado inicial del hash son cinco palabras de 32 bits (A-E), y el hash final es la concatenación de esas palabras tras el último bloque. Implementación definida en FIPS 180-1 (1995), reemplazado por FIPS 180-4 (2015) que incluye formalmente el lenguaje de deprecación.

Salida: 160 bits, 40 caracteres hexadecimales

Siempre exactamente 40 caracteres hexadecimales en minúsculas (160 bits = 20 bytes, codificados como 2 caracteres hex por byte). La longitud de salida es fija independientemente del tamaño de la entrada. Comparado con los 64 caracteres de SHA-256, la salida más corta proporciona menos bits de resistencia a colisiones — un factor clave por el que SHA-1 fue roto antes que SHA-256.

Rendimiento: rápido, y eso forma parte del problema

SHA-1 es rápido — típicamente 400-700 MB/s en un navegador usando Web Crypto, competitivo con SHA-256. Para un atacante, esta velocidad es una ventaja: un clúster moderno de GPUs puede calcular miles de millones de hashes SHA-1 por segundo, acelerando los ataques de fuerza bruta y la búsqueda de colisiones. La velocidad es la razón por la que SHA-1 (como MD5) nunca debe usarse para almacenamiento de contraseñas — usa bcrypt, scrypt o Argon2 en su lugar.

Estándares: FIPS 180-1 (1995) — deprecado en el contexto de FIPS 180-4

SHA-1 fue estandarizado en FIPS 180-1 (1995), reemplazando al defectuoso SHA-0. El NIST deprecó SHA-1 para firmas digitales en NIST SP 800-131A (2011) y en FIPS 186-5 (2023) lo prohibió formalmente para toda generación de firmas digitales. RFC 6194 (2011) documentó las consideraciones de seguridad conocidas. La API WebCrypto del W3C todavía incluye SHA-1 por razones de interoperabilidad con sistemas heredados, que es cómo esta herramienta de navegador puede calcularlo.

Buenas prácticas

Nunca uses SHA-1 para operaciones sensibles a la seguridad

SHA-1 está deprecado para firmas digitales, certificados TLS, firma de código, almacenamiento de contraseñas y cualquier flujo de trabajo donde importe la resistencia a colisiones. El ataque SHAttered de 2017 demostró colisiones prácticas. Para todos los usos de seguridad, migra a SHA-256 o SHA-3. La diferencia de coste es insignificante en hardware moderno — SHA-256 está acelerado por hardware en todas las CPUs actuales.

SHA-1 para consultas de huellas heredadas es aceptable

Si necesitas verificar un checksum de archivo anterior a 2017, consultar un ID de commit de Git, o inspeccionar una huella de certificado antiguo con fines de auditoría, SHA-1 es apropiado. El hash en sí no se usa para tomar una decisión de confianza — solo reproduces una huella conocida para referencia cruzada. Documenta esto explícitamente en tus registros de auditoría: 'SHA-1 usado solo como referencia heredada, no para validación de seguridad'.

Siempre hashea bytes UTF-8, no puntos de código Unicode

SHA-1, como todos los algoritmos de hash, opera sobre bytes, no sobre caracteres. La misma cadena codificada como UTF-8 frente a UTF-16 produce hashes diferentes. Esta herramienta siempre codifica la entrada como UTF-8 sin BOM antes de hashear. Si necesitas coincidir con un sistema que usa una codificación diferente (Windows UTF-16-LE, Latin-1), debes pre-codificar la entrada externamente antes de comparar hashes.

Usa comparación en tiempo constante al verificar hashes en código

Si comparas dos hashes SHA-1 en código, usa una verificación de igualdad en tiempo constante — Node.js crypto.timingSafeEqual(), Python hmac.compare_digest() — en lugar de igualdad de cadenas simple (=== o ==). La comparación simple filtra información de temporización que teóricamente puede permitir a un atacante reconstruir el hash esperado byte a byte. Esta es una medida de defensa en profundidad incluso para verificación SHA-1 heredada.

Preguntas frecuentes sobre SHA-1