Generador de Hashes y Verificador de Checksums

Calcule y verifique resúmenes MD5, SHA-1, SHA-256, SHA-384, SHA-512 y CRC-32 o firmas HMAC para cadenas de texto y archivos locales de forma segura en su navegador.

Texto de entrada / Cadena

Formato de entrada:

Ejemplos:

Longitud: 13 caracteres•Bytes: 13 B

Hashes calculados6 algoritmos

MD5(128-bit)

Vulnerable (Solo checksums)

...

SHA-1(160-bit)

En desuso (Solo legado)

...

SHA-256(256-bit)

Alta seguridad (Estándar)

...

SHA-384(384-bit)

Alta seguridad

...

SHA-512(512-bit)

Máxima seguridad

...

CRC-32(32-bit)

Solo checksum (No criptográfico)

...

Cómo calcular y verificar sumas de comprobación

Seleccionar modo de cálculo: Utilice Hash de texto para procesar cadenas y cargas útiles; Suma de comprobación para paquetes y archivos binarios; Verificador de checksum para contrastar con el resumen oficial de una versión; o Generador HMAC para autenticación con clave secreta.
Proporcionar entrada: Escriba o pegue texto (admite secuencias UTF-8, cadenas hexadecimales o bytes en Base64), o arrastre y suelte cualquier archivo local en la interfaz de cálculo.
Configurar codificación de salida: Alterne entre formato hexadecimal en minúsculas (abc), mayúsculas (ABC) o codificación Base64 mediante los controles de la barra superior.
Exportar resúmenes: Haga clic en el botón de copia situado junto a cada resumen o use Copiar todo para transferir simultáneamente todos los hashes calculados al portapapeles en un manifiesto estructurado.
Validar hashes oficiales: En la pestaña Verificador de checksum, pegue el hash esperado de un repositorio oficial o aviso de seguridad para verificar automáticamente la autenticidad e integridad.

Matriz comparativa de funciones hash criptográficas

Parámetros arquitectónicos, dimensiones de bloque y recomendaciones de despliegue en entornos de producción según estándares internacionales.

Algoritmo	Estándar	Tamaño del resumen	Tamaño del bloque	Tamaño de palabra	Estado de seguridad	Caso de uso principal
MD5	RFC 1321 (1992)	128 bits (16 B)	512 bits (64 B)	32 bits	Vulnerable (Colisiones probadas)	Verificación de ETag en S3, desduplicación no adversarial, claves de caché heredadas
SHA-1	FIPS 180-4 (1995)	160 bits (20 B)	512 bits (64 B)	32 bits	En desuso (Colisión SHAttered)	Identificadores históricos de commits en Git, certificados TLS antiguos, infohashes de BitTorrent
SHA-256	FIPS 180-4 / SHA-2	256 bits (32 B)	512 bits (64 B)	32 bits	Estándar (Aprobado por NIST)	Certificados TLS 1.3, PoW de Bitcoin, resúmenes de imágenes Docker, firma de paquetes de software
SHA-384	FIPS 180-4 / SHA-2	384 bits (48 B)	1024 bits (128 B)	64 bits	Alta seguridad (SHA-512 truncado)	Criptografía Suite B de la NSA, VPNs empresariales, acuerdos TLS de alta seguridad
SHA-512	FIPS 180-4 / SHA-2	512 bits (64 B)	1024 bits (128 B)	64 bits	Máxima (Aprobado por NIST)	Firmas digitales (Ed25519), sales para contraseñas shadow, flujos en servidores de 64 bits
CRC-32	IEEE 802.3 (1975)	32 bits (4 B)	Transmisión a nivel de bit	32 bits	No criptográfico (Detección de errores)	Cabeceras de archivos ZIP/GZIP, secuencia de verificación de tramas Ethernet, validación de chunks PNG

Mecánica interna: Construcción de Merkle–Damgård y extensión de longitud

Procesamiento y compresión por bloques

Los algoritmos de las familias MD5 y SHA se fundamentan en la construcción de Merkle–Damgård. Antes del procesamiento, el mensaje original se rellena con un único bit 1, seguido de los bits 0 necesarios, y finaliza con un entero de 64 bits (o 128 bits en SHA-512) que codifica la longitud original del mensaje. Esto garantiza que el flujo de datos se divida de manera exacta en bloques fijos:

Bloques de 512 bits (64 bytes): MD5, SHA-1, SHA-256.
Bloques de 1024 bits (128 bytes): SHA-384, SHA-512.

Cada bloque se procesa mediante una función de compresión unidireccional junto con el estado intermedio del bloque anterior (inicializado con vectores de inicialización estándar o IV).

Vulnerabilidad de extensión de longitud y la solución HMAC

Debido a que el resumen final de SHA-256 coincide con el estado interno bruto de la última compresión de bloque, las firmas ingenuas del tipo Hash(Secreto || Mensaje) son vulnerables a ataques de extensión de longitud (Length Extension Attacks). Un atacante que conozca la longitud del mensaje y el hash resultante puede calcular rondas posteriores con datos anexados sin descubrir la clave secreta.

HMAC (RFC 2104) anula por completo esta vulnerabilidad mediante una arquitectura de hash anidado de doble pasada con constantes de relleno interno y externo:

HMAC(K, M) = H((K' ⊕ 0x5c) || H((K' ⊕ 0x36) || M))

Trampas prácticas: Por qué difieren las sumas de comprobación en entornos reales

1. Saltos de línea CRLF frente a LF

Los archivos de texto en Windows y repositorios Git con core.autocrlf=true insertan retorno de carro (\r\n / 0x0D 0x0A), mientras que Linux y macOS emplean solo salto de línea (\n / 0x0A). Aunque el texto visible parezca idéntico, la secuencia binaria cambia por completo el hash. Normalice siempre los saltos de línea al comparar datos entre plataformas.

2. Salto de línea implícito en echo de consola

Ejecutar echo "password" | sha256sum agrega automáticamente un salto de línea final (0x0A) antes de pasarlo a la tubería, calculando el hash de 9 bytes en vez de 8. En Bash, use siempre echo -n "password" | sha256sum o printf "%s" "password" | sha256sum.

3. Sensibilidad a mayúsculas y minúsculas en cadenas hexadecimales

Las salidas de hash son arrays de bytes binarios representados en hexadecimal. Aunque e3b0c442... y E3B0C442... representan exactamente el mismo array de bytes, una comparación estricta de cadenas (===) fallará. Convierta ambas cadenas a minúsculas antes de validarlas.

4. Desbordamiento de memoria con archivos pesados

Intentar cargar una imagen de disco de 4 GB completa en memoria con fs.readFileSync() satura la memoria heap de Node.js o del navegador. Las canalizaciones de producción deben procesar los datos de forma incremental en fragmentos controlados (típicamente de 64 KB a 1 MB) mediante hasher.update(chunk).

Aviso de seguridad: Nunca utilice hashes rápidos (SHA-256 / MD5) para almacenar contraseñas

Las funciones hash criptográficas como SHA-256, SHA-512 y MD5 están deliberadamente optimizadas para un alto rendimiento de procesamiento. Una tarjeta gráfica moderna o un clúster ASIC puede calcular más de 10.000 millones de hashes SHA-256 por segundo. Si un atacante accede a contraseñas almacenadas con hashes simples sin sal, los ataques por diccionario y fuerza bruta tienen éxito en cuestión de minutos.

Para almacenar credenciales de autenticación, emplee siempre funciones de derivación de claves (KDF) lentas y con alto consumo de memoria:

Argon2id (RFC 9106)

KDF de última generación que combina accesos a memoria dependientes e independientes de datos. Resiste la paralelización en GPU y ataques de canal lateral de caché.

bcrypt (OpenBSD)

Esquema adaptativo basado en el cifrado Blowfish con factor de coste configurable y generación de sal de 128 bits. Ampliamente probado y desplegado en producción.

scrypt (RFC 7914)

Función con fuerte dependencia de memoria que exige amplios bloques de RAM activa, haciendo que el diseño de hardware ASIC o FPGA personalizado resulte económicamente inviable.

Referencia rápida de línea de comandos: Comandos de hash en terminal

Comandos estándar nativos para generar resúmenes SHA-256 y MD5 en diversos sistemas operativos sin instalar software de terceros:

# Linux / POSIX:
sha256sum release.tar.gz
md5sum release.tar.gz
printf "%s" "cadena-origen" | sha256sum

# macOS (BSD coreutils):
shasum -a 256 release.dmg
md5 release.dmg
printf "%s" "cadena-origen" | shasum -a 256

# Windows PowerShell:
Get-FileHash -Algorithm SHA256 .\installer.msi
Get-FileHash -Algorithm MD5 .\installer.msi

# Símbolo del sistema de Windows (cmd.exe):
certutil -hashfile .\installer.msi SHA256

# OpenSSL (multiplataforma):
openssl dgst -sha256 release.tar.gz
openssl dgst -sha256 -hmac "clave-secreta" payload.json

Implementación para desarrolladores: Cálculo de hashes en múltiples lenguajes

Fragmentos de código estándar para calcular hashes SHA-256 y HMAC en los principales ecosistemas y entornos de ejecución.

Lenguaje

Node.js•Transmisión con node:crypto y cálculo sobre buffers

nodejs

import { createHash, createHmac } from 'node:crypto';

// Calcular SHA-256 de una cadena
const hash = createHash('sha256').update('datos').digest('hex');

// Calcular HMAC-SHA256 con clave secreta
const hmac = createHmac('sha256', 'clave-secreta').update('payload').digest('hex');

Web Crypto•Estándar nativo para navegadores y entornos Edge

webcrypto

// Calcular SHA-256 en el navegador
const encoder = new TextEncoder();
const data = encoder.encode('datos');
const hashBuffer = await crypto.subtle.digest('SHA-256', data);
const hashArray = Array.from(new Uint8Array(hashBuffer));
const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');

Python•Biblioteca estándar hashlib y hmac

python

import hashlib
import hmac

# Resumen SHA-256
datos = b"datos"
sha256_hex = hashlib.sha256(datos).hexdigest()

# Firma HMAC-SHA256
firma = hmac.new(b"clave-secreta", datos, hashlib.sha256).hexdigest()

Go•Paquetes crypto de la biblioteca estándar

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
)

func Sha256(data []byte) string {
	sum := sha256.Sum256(data)
	return hex.EncodeToString(sum[:])
}

func HmacSha256(key, message []byte) string {
	mac := hmac.New(sha256.New, key)
	mac.Write(message)
	return hex.EncodeToString(mac.Sum(nil))
}

Rust•Crates sha2 y hmac (RustCrypto)

rust

use sha2::{Sha256, Digest};
use hmac::{Hmac, Mac};

// SHA-256 estándar
let mut hasher = Sha256::new();
hasher.update(b"datos");
let result = hex::encode(hasher.finalize());

// HMAC-SHA256 con clave
type HmacSha256 = Hmac<Sha256>;
let mut mac = HmacSha256::new_from_slice(b"clave-secreta").unwrap();
mac.update(b"payload");
let hmac_hex = hex::encode(mac.finalize().into_bytes());

C# / .NET•APIs modernas sin asignación (.NET 7+)

csharp

using System.Security.Cryptography;
using System.Text;

byte[] bytes = Encoding.UTF8.GetBytes("datos");
string hashHex = Convert.ToHexStringLower(SHA256.HashData(bytes));

byte[] key = Encoding.UTF8.GetBytes("clave-secreta");
string hmacHex = Convert.ToHexStringLower(HMACSHA256.HashData(key, bytes));

Java•java.security.MessageDigest y Mac (Java 17+)

java

import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;
import java.util.HexFormat;

MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[] digest = md.digest("datos".getBytes(StandardCharsets.UTF_8));
String hashHex = HexFormat.of().formatHex(digest);

PHP•Funciones hash nativas (PHP 8+)

php

<?php
$data = 'datos';
$key  = 'clave-secreta';

$sha256 = hash('sha256', $data);
$hmac   = hash_hmac('sha256', $data, $key);

Aplicaciones esenciales en ingeniería de software

Verificación de versiones binarias: Publicar hashes SHA-256 junto con archivos ejecutables e imágenes ISO permite a gestores de paquetes y usuarios certificar que las descargas no fueron manipuladas en tránsito.
Almacenamiento direccionable por contenido (CAS): Git utiliza resúmenes SHA-1 / SHA-256 como identificadores inmutables de objetos. Motores de contenedores como Docker y OCI identifican capas de imágenes estrictamente mediante su digest (sha256:7f3b...).
Autenticidad de webhooks (HMAC): Plataformas como GitHub, Stripe, Shopify y AWS firman cargas útiles HTTP salientes mediante encabezados HMAC-SHA256 para que los servidores receptores validen el origen y la integridad del mensaje.
Invalidación de caché en el frontend: Empaquetadores modernos (Vite, Webpack, Rollup) adjuntan hashes basados en el contenido a los nombres de archivo (app.[contenthash].js) garantizando que los navegadores solo invaliden activos modificados.
Integridad de subrecursos (SRI): Los navegadores comprueban scripts de terceros mediante atributos criptográficos (integrity="sha384-...") bloqueando su ejecución si una red CDN resulta comprometida.

Frequently Asked Questions

¿Cómo verificar la suma de comprobación de un archivo descargado con SHA-256 o MD5?

Arrastre y suelte el archivo descargado en la pestaña "Suma de comprobación", luego cambie a la pestaña "Verificador de checksum" y pegue el hash publicado en el sitio oficial de descargas o boletín de seguridad. El verificador comparará automáticamente el valor contra todos los resúmenes calculados y mostrará la confirmación de coincidencia. En terminal, puede verificar mediante "sha256sum archivo" (Linux), "shasum -a 256 archivo" (macOS) o "Get-FileHash archivo -Algorithm SHA256" (Windows PowerShell).

¿Cuál es la diferencia entre SHA-256 y MD5, y cuándo utilizar cada uno?

MD5 genera un resumen de 128 bits (32 caracteres hexadecimales) y está criptográficamente vulnerado; las colisiones demostradas implican que nunca debe utilizarse para firmas de seguridad, certificados digitales ni autenticación. No obstante, MD5 sigue siendo una suma de comprobación rápida y eficaz para desduplicación de almacenamiento y detección de errores accidentales de transferencia (como los ETags de Amazon S3). SHA-256 produce un resumen de 256 bits (64 caracteres hexadecimales) con sólida resistencia a colisiones, siendo el estándar de la industria moderna para versiones de software, certificados TLS/SSL y sistemas blockchain.

¿Por qué el hash de un texto no coincide con la salida del terminal u otra herramienta?

Las discrepancias en los hashes casi siempre provienen de caracteres invisibles o diferencias de codificación: 1) Salto de línea final: comandos de consola como 'echo "hola" | sha256sum' añaden un byte de salto de línea invisible \n (0x0A), calculando el hash de 5 bytes en lugar de 4. Utilice 'printf "%s" "hola" | sha256sum' o 'echo -n "hola" | sha256sum'. 2) Finales de línea: los archivos de texto en Windows emplean CRLF (\r\n), mientras que en Linux se usa LF (\n). 3) Codificación de caracteres: asegúrese de que la cadena origen se interprete con los mismos bytes binarios (p. ej., UTF-8 frente a UTF-16).

¿Qué es un HMAC y en qué se diferencia de un hash estándar?

Un hash estándar (como SHA-256) únicamente garantiza la integridad de los datos, demostrando si el mensaje fue alterado. Un HMAC (Código de autenticación de mensajes basado en hash, RFC 2104) incorpora una clave criptográfica secreta compartida junto con el mensaje mediante un algoritmo de doble pasada anidada. Esto valida tanto la integridad de los datos como la autenticidad del mensaje (confirmando que la carga útil fue firmada por quien posee la clave secreta) y previene los ataques de extensión de longitud. HMAC-SHA256 es el estándar universal para firmas de webhooks (Stripe, GitHub, Shopify) y autenticación en APIs REST.

¿Afecta la representación en mayúsculas, minúsculas o Base64 al valor del hash?

No. El resumen del hash es un array inmutable de bytes binarios puros (por ejemplo, exactamente 32 bytes para SHA-256). El formato hexadecimal es simplemente una representación textual legible por humanos donde las minúsculas ("a-f") y las mayúsculas ("A-F") representan valores numéricos idénticos. Base64 es una codificación ASCII más compacta de 64 caracteres (44 caracteres para SHA-256 frente a 64 caracteres en hexadecimal). Puede alternar entre hexadecimal en minúsculas, mayúsculas y Base64 en la barra de herramientas para adaptarse a la especificación de su API.

¿Se pueden procesar archivos de gran tamaño en el navegador y cuáles son los límites?

Sí, los archivos se procesan íntegramente en el cliente dentro del navegador utilizando la Web Cryptography API y arrays tipados nativos, sin transmitir ningún byte al servidor, lo que garantiza total privacidad. Dado que el cálculo en el navegador opera dentro del montón de memoria (heap) de la pestaña, los archivos de hasta varios cientos de megabytes o entre 1 GB y 2 GB (según la memoria RAM disponible del sistema) se procesan con fluidez. Para imágenes de disco masivas de varios gigabytes que superen los límites de memoria de la pestaña, se recomienda el uso de utilidades nativas de terminal (como "sha256sum", "shasum -a 256" o PowerShell "Get-FileHash").

¿Se puede revertir o desencriptar un hash criptográfico como SHA-256 o MD5?

No. El hashing es una función matemática unidireccional, fundamentalmente distinta del cifrado. El cifrado es reversible mediante una clave de descifrado, mientras que el hashing comprime permanentemente datos de longitud arbitraria en un resumen de longitud fija, descartando de forma irreversible la información de entrada original. Matemáticamente no es posible descifrar un hash; los atacantes solo pueden intentar adivinar entradas y cotejar las salidas en bases de datos precalculadas o tablas arcoíris.

¿Por qué nunca se debe utilizar SHA-256 o MD5 directamente para almacenar contraseñas en una base de datos?

Las funciones hash criptográficas de propósito general están deliberadamente optimizadas para un alto rendimiento en hardware (cientos de megabytes por segundo). Las tarjetas gráficas modernas y los clústeres ASIC pueden procesar más de 10.000 millones de hashes SHA-256 por segundo, permitiendo ataques por fuerza bruta o tablas arcoíris contra bases de datos en cuestión de minutos. El almacenamiento de contraseñas exige funciones de derivación de claves (KDF) lentas y de alta demanda de memoria, como Argon2id (RFC 9106), bcrypt o scrypt, que imponen retrasos computacionales y un elevado uso de RAM para neutralizar ataques en hardware paralelo.

Convertidor Hexadecimal

Generador y Validador de UUID

Codificador y Decodificador Base64