Generador de hash y HMAC: MD5, SHA-256 y SHA-512 en línea

Un digest prueba los bytes; HMAC prueba quién los envió

Un hash y un HMAC responden preguntas distintas. El SHA-256 de una cadena dice si esa cadena sigue coincidiendo con una huella publicada. El HMAC-SHA-256 de la misma cadena, más un secreto compartido, dice si alguien que conoce el secreto la produjo. Ninguno de los dos es cifrado, ni un almacén de contraseñas. FastMinify separa los trabajos: el generador de hash en línea calcula MD5, SHA-1, SHA-256, SHA-384 y SHA-512 a partir de texto UTF-8, y el generador HMAC firma un mensaje con HMAC-SHA-256, SHA-384 o SHA-512. Ambos corren en la pestaña vía Web Crypto (MD5 es una implementación local, porque Web Crypto no lo ofrece). No se sube nada. Los dos están en el hub de herramientas de codificación, junto a Base64 y las ayudas JWT — la codificación escribe bytes, el hash los huella.

Cinco digest a la vez en la página de hash: SHA-256, SHA-384, SHA-512, SHA-1, MD5

HMAC limitado a SHA-256, SHA-384 y SHA-512 — sin modo MD5 o SHA-1 con clave

Salida: hex minúsculas o mayúsculas, Base64 con padding, o Base64URL sin padding

Pega un digest esperado: se resaltan los algoritmos que coinciden; se ignoran mayúsculas hex, espacios y el padding Base64URL

Codificación de la clave HMAC: texto UTF-8 (por defecto), bytes hex, o bytes Base64 / Base64URL

La página de hash acepta un archivo de texto (txt, md, json, csv, html, xml, yml, yaml) hasta 32 MiB, leído como UTF-8 — no un sha256sum binario

Cuándo el navegador es el sitio correcto para hashear

Buenos usos

Una cadena que puedes pegar, un secreto que aceptas teclear en tu propio navegador, un digest que ya tienes.

Comprobar el SHA-256 de una fixture corta contra un test unitario o un ejemplo de la doc (abc — la página borra el resultado si el campo está vacío o solo tiene espacios; el digest de la cadena vacía se ve en un REPL, no en la herramienta)

Comparar un cuerpo JSON o YAML que acabas de editar con el digest que envió un compañero, tras acordar LF o CRLF

Reproducir un HMAC al estilo GitHub del cuerpo en bruto y comparar el hex sin el prefijo sha256=

Ver a qué algoritmo pertenece un hex desconocido: pégalo en Digest esperado y deja que se enciendan las cinco tarjetas

Enseñar la distancia entre Base64, un hash y HMAC sin instalar Node

Déjalo en la máquina que tiene el archivo o la clave

Si los bytes son un artefacto binario, o el secreto no debe aparecer en un navegador de una máquina compartida, quédate en la shell o en CI.

Archivos de release, contenedores, imágenes, PDF — sha256sum u openssl dgst sobre el archivo, no esta página

Archivos de más de 32 MiB, o extensiones fuera de la lista de texto — el selector los rechaza

Bases de contraseñas — <a href="/es/bcrypt-hash" class="text-primary hover:underline">bcrypt</a>, no SHA

Un JWT que debes aceptar o rechazar — <a href="/es/jwt-verify" class="text-primary hover:underline">jwt-verify</a>, no un HMAC artesanal del JSON de los claims

Un repo que quizá ya contiene un secreto de firma — <a href="/es/scan-secrets" class="text-primary hover:underline">escanear secretos</a> antes de rotar la clave que acabas de pegar

Errores de hash que parecen una coincidencia

Usar SHA o MD5 como hash de contraseña

Un digest simple es rápido, sin sal, e idéntico para la misma entrada. Eso es lo que quieres en un checksum. No es lo que quieres en una contraseña: un atacante precalcula el digest, y dos usuarios con la misma contraseña comparten una fila. La documentación de las páginas de hash y HMAC lo dice. Las contraseñas van en bcrypt-hash (o Argon2 en tu servidor). HMAC tampoco sirve: autentica un mensaje con un secreto que debes guardar, no estira una contraseña.

Guardar SHA-256(contraseña) y llamar a la columna «hasheada»

Usar HMAC(contraseña, pepper) en lugar de bcrypt porque «tiene clave»

Comparar el MD5 de una passphrase para decidir un login

Creer que un digest más largo (SHA-512) sustituye la sal y el factor de coste

Checksums y firmas de webhook aquí. Contraseñas en bcrypt, con un coste que el servidor pueda asumir.

Tomar un hash por una firma, o Base64 por un hash

Cualquiera puede recalcular el SHA-256 de un cuerpo público. El digest prueba que el cuerpo no cambió; no prueba quién lo produjo. Si un webhook, una nota de versión o una llamada de API debe ser auténtica, hace falta un secreto: HMAC, o una firma JWT comprobada con jwt-verify. La confusión inversa es igual de habitual tras la guía de codificar y decodificar Base64: Base64 es un envoltorio reversible. El SHA-256 de abc es ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad. De ese hex no se vuelve a abc.

Publicar un SHA-256 junto a un cuerpo JSON y decir que el cuerpo está firmado

Decodificar un digest con la herramienta Base64 esperando el texto original

Pegar un JWT en el generador de hash para ver si es válido

Ocultar una clave de API hasheándola y luego no poder recuperarla cuando el servidor aún la necesita

Integridad sin secreto → hash. Integridad con secreto compartido → HMAC. Confidencialidad → cifrado, que estas páginas no hacen. Escritura reversible → Base64.

Checksum de un archivo que no son los bytes del disco

El generador de hash huella texto UTF-8, no un archivo en bruto. La subida acepta solo extensiones de texto — txt, md, json, csv, html, xml, yml, yaml — hasta el tope de cliente de 32 MiB, y el archivo se lee como texto antes de hashear. El SHA-256 de un proveedor para un .tar.gz, una imagen o un PDF no coincidirá, y esos tipos no están en el selector. Incluso un archivo de texto puede discrepar de sha256sum si cambian los saltos de línea. El SHA-256 de abc es el vector de arriba. El SHA-256 de abc más un solo LF es edeaaff3f1774ad2888673770c6d64097e391bc362d7d6fb34982ddf0efd18cb. Las mismas letras, bytes distintos.

Soltar un archivo de release y esperar el checksum del proveedor

Comparar un archivo Windows CRLF con un digest Linux LF

Usar <code>echo abc | sha256sum</code> (echo añade un salto de línea) y culpar al navegador

Renombrar un binario a .txt para que el selector lo acepte — los bytes ya no son los del archivo

La página es la herramienta correcta para un fragmento, un cuerpo JSON o una fixture de texto. Los artefactos binarios se quedan en <code>sha256sum</code> u <code>openssl dgst</code>.

Firmar una cadena distinta a la del webhook

El X-Hub-Signature-256 de GitHub es sha256= más el HMAC-SHA-256 del cuerpo en bruto, secreto en UTF-8. Stripe firma timestamp.payload, no el JSON solo. La página HMAC no construye esas cadenas ni quita un prefijo sha256=. Pega el mensaje exacto, los bytes exactos de la clave y solo el digest. La comparación ignora mayúsculas hex y espacios, y el = final en Base64URL. No ignora un prefijo.

Pegar toda la cabecera <code>sha256=f7bc…</code> en Digest esperado

Reindentar el JSON antes de firmar — los espacios cambian el HMAC

Dejar la codificación de clave en UTF-8 cuando el secreto es una clave hex o Base64

Pedir HMAC-MD5 o HMAC-SHA-1 — esos algoritmos solo están en la página de hash

Reproduce la entrada exacta del proveedor. Si la firma sigue sin coincidir, el fallo está en los bytes que diste, no en un segundo algoritmo.

Qué algoritmo, qué escritura, qué herramienta

Hash, HMAC, bcrypt, JWT — cuatro cerraduras distintas

Todos emiten cadenas opacas. No se sustituyen.

Generador de hash: sin secreto. MD5, SHA-1, SHA-256, SHA-384, SHA-512 de texto UTF-8. Los cinco se actualizan juntos; un digest esperado resalta los algoritmos que coinciden.

Generador HMAC: secreto compartido obligatorio. HMAC-SHA-256 (por defecto), SHA-384 o SHA-512. Mensaje vacío o secreto vacío es un error. Sin subida de archivo.

bcrypt-hash: almacenamiento de contraseñas. Lento a propósito. No envíes una cadena bcrypt a la página de hash esperando una coincidencia.

jwt-verify: comprueba un JWT compacto (header.payload.signature) contra una clave o un JWKS. HMAC-SHA-256 es la primitiva detrás de HS256, pero la entrada firmada es base64url(header).base64url(payload), no los claims JSON. jwt-verify para tokens; HMAC para un mensaje en bruto.

Hex, Base64, Base64URL

Los bytes del digest no cambian. La escritura sí. Hex es lo que imprimen sha256sum y la mayoría de docs de webhooks. Base64 con padding es lo que devuelven algunas API. Base64URL sin padding es la forma compacta (sin +, / ni = final). Las mayúsculas solo aplican al hex.

Vector NIST, entrada abc, SHA-256 hex: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad — 64 caracteres hex, 32 bytes

La misma entrada, MD5 hex: 900150983cd24fb0d6963f7d28e17f72 — 32 caracteres hex. Solo checksums heredados; no arranques un protocolo nuevo sobre MD5 o SHA-1

HMAC-SHA-256, clave los cuatro caracteres key, mensaje The quick brown fox jumps over the lazy dog, hex: f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8

El mismo HMAC en Base64 con padding: 97yD9DBThCSxMpjmqm+xQ+9NWaFJRhdZl0edvC0aPNg= — Base64URL quita el padding y cambia + y /: 97yD9DBThCSxMpjmqm-xQ-9NWaFJRhdZl0edvC0aPNg

Longitudes que conviene contar antes de fiarse de un pegado

Un digest truncado es una copia fallida, no otro algoritmo. Cuenta los caracteres después de quitar los espacios.

MD5: 16 bytes → 32 hex, o 24 caracteres Base64 con padding

SHA-1: 20 bytes → 40 hex. Hay colisiones; consérvalo solo para manifiestos heredados

SHA-256: 32 bytes → 64 hex, 44 Base64 con un =, 43 Base64URL sin padding

SHA-384: 48 bytes → 96 hex. SHA-512: 64 bytes → 128 hex. La longitud de salida HMAC sigue el hash elegido

Calcular un digest y luego firmar un mensaje

Hashear una cadena o un archivo de texto

Abre el generador de hash. Pega el texto o sube un archivo de texto. Elige hex, Base64 o Base64URL. Activa las mayúsculas solo si el digest de referencia está en versales — no cambia nada en Base64. Los cinco algoritmos se refrescan juntos. Pega el digest esperado para resaltar coincidencias. Carga el ejemplo si solo quieres ver el flujo. El campo debe contener texto que no sea solo espacios; un campo vacío borra las tarjetas en lugar de mostrar el SHA-256 conocido de la cadena vacía.

Paso 1 — Pegar los bytes exactos como texto

Acuerda los saltos de línea. Un LF final forma parte de la entrada. No reindentes el JSON si el otro lado hasheó la forma compacta.

Paso 2 — Igualar la escritura de salida

Hex para checksums y herramientas CLI. Base64 con padding cuando la API muestra + / y =. Base64URL sin padding cuando el digest va en un token o una URL.

Paso 3 — Pegar el digest esperado

La comparación ignora mayúsculas hex y espacios, y el padding Base64URL. Una coincidencia resalta el algoritmo. Ningún resalte: bytes distintos, escritura distinta, o un prefijo que aún hay que quitar.

Firmar con HMAC

Abre el generador HMAC. No hay subida de archivo: pega el mensaje y el secreto. Deja SHA-256 salvo que el proveedor diga SHA-384 o SHA-512. Pon la codificación de clave en UTF-8 para un secreto tipo passphrase, hex para una clave hex (prefijo 0x opcional, longitud par), o Base64 si la clave se guardó así. UTF-8 sobre un secreto hex firma los caracteres 0-9a-f, no los bytes de la clave — el digest no coincide y el error no es obvio. El digest esperado usa las mismas reglas que la página de hash.

Algoritmos: HMAC-SHA-256 (por defecto), SHA-384, SHA-512 — solo Web Crypto

Mensaje y secreto son obligatorios; los valores solo con espacios se rechazan

Salida: hex, Base64 con padding, Base64URL sin padding; las mayúsculas solo afectan al hex

El secreto se queda en la pestaña. Ciérrala al terminar; la página no es una caja fuerte

La entrada firmada de un JWT HS256 no es el objeto de claims — jwt-encode / jwt-verify para tokens

Los mismos bytes en Node y openssl

Node crypto — UTF-8, sin salto de línea extra

createHash y createHmac hashean la cadena que pasas. No añaden un salto de línea. Eso coincide con las herramientas del navegador.

Ejemplo básico

const crypto = require('node:crypto')

const sha256 = crypto.createHash('sha256').update('abc').digest('hex')
// ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

const hmac = crypto.createHmac('sha256', 'key')
  .update('The quick brown fox jumps over the lazy dog')
  .digest('hex')
// f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8

openssl — printf, no echo

echo añade un salto de línea, así que el digest es de otros bytes. printf no. Para un archivo en disco, pasa -binary solo si quieres los bytes crudos del digest; hex es la forma de texto.

Ejemplo básico

printf 'abc' | openssl dgst -sha256
# ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

printf 'The quick brown fox jumps over the lazy dog' | openssl dgst -sha256 -hmac key
# f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8

# artefacto binario — no la herramienta del navegador
openssl dgst -sha256 release.tar.gz

FastMinify hash-generator / hmac-generator

Sin instalación, sin subida a un servidor, cinco algoritmos de hash o tres de HMAC, hex / Base64 / Base64URL, y un resalte del digest esperado. El límite: solo texto y UTF-8, tope de 32 MiB para archivos de texto en la página de hash, sin checksum binario, sin HMAC-MD5, sin estiramiento de contraseñas, sin ensamblado de JWT. Usa las páginas para inspeccionar un fragmento o reproducir una firma de webhook. Deja openssl en el artefacto de release y bcrypt en la contraseña.

Conclusión

Hashea el texto cuando necesitas saber que no cambió. Pásalo por HMAC cuando un secreto compartido debe probar quién lo produjo. FastMinify hace ambas cosas en el navegador: de MD5 a SHA-512 para texto UTF-8 (y archivos de texto de hasta 32 MiB), HMAC-SHA-256/384/512 con una clave UTF-8, hex o Base64, escrita como hex, Base64 o Base64URL sin padding. No hará el checksum de un archivo comprimido, no guardará una contraseña y no verificará un JWT. Eso se queda en openssl, bcrypt y jwt-verify. Empieza en el hub de herramientas de codificación mientras la cadena siga siendo texto.

Hashear o firmar en el navegador

SHA-256 para checksums nuevos; MD5 y SHA-1 solo si un manifiesto heredado los exige

HMAC cuando hay un secreto compartido; un hash a secas no autentica al emisor

Iguala saltos de línea y escritura (hex, Base64, Base64URL) antes de dar un digest por malo

Solo archivos de texto en el navegador — los binarios se quedan en openssl o sha256sum

Las contraseñas van a bcrypt; los tokens a jwt-verify

Generador de hash y HMAC: MD5, SHA-256 y SHA-512 en línea

Un digest prueba los bytes; HMAC prueba quién los envió

Cuándo el navegador es el sitio correcto para hashear

Errores de hash que parecen una coincidencia

Qué algoritmo, qué escritura, qué herramienta

Calcular un digest y luego firmar un mensaje

Paso 1 — Pegar los bytes exactos como texto

Paso 2 — Igualar la escritura de salida

Paso 3 — Pegar el digest esperado

Los mismos bytes en Node y openssl

Ejemplo básico

Ejemplo básico

Conclusión

Artículos relacionados