Qué es un hash y para qué sirve (MD5, SHA1, SHA256, SHA512)

Qué es un hash, explicado sin humo

Un hash es el resultado de aplicar una función hash a unos datos (texto, fichero, bytes). Esa función genera una “huella digital” de longitud fija llamada digest. Lo importante: para una entrada dada, el resultado es siempre el mismo.

Puedes pensar en un hash como en un “resumen” ultra-sensible: un cambio mínimo en la entrada (una letra, un espacio o un byte) cambia por completo la salida. A esto se lo suele llamar efecto avalancha.

Para qué sirve un hash en la práctica

Aunque se usan en criptografía, los hashes aparecen todo el tiempo en informática cotidiana. Los usos más comunes:

• Verificar integridad de archivos descargados (checksums).
• Detectar cambios en configuraciones, payloads o documentos.
• Comparar contenidos sin necesidad de guardarlos completos (por ejemplo, cachés).
• Identificar de forma estable objetos o mensajes (IDs derivados).
• Almacenar contraseñas (pero bien: con sal y un algoritmo adecuado; lo veremos más abajo).

Si quieres probarlo ya mismo, abre el generador de hash online, pega una frase y cambia un solo carácter: vas a ver cómo el hash cambia de forma drástica.

Hash vs cifrado: no son lo mismo

Un punto clave: un hash no es cifrado. El cifrado está pensado para ser reversible (si tienes la clave, puedes recuperar el texto original). Un hash, en cambio, es unidireccional: no se “descifra”. Puedes intentar adivinar la entrada probando muchas opciones, pero no existe un botón de “deshacer hash”.

Esto explica por qué en seguridad hablamos de resistencia a preimagen (que sea difícil encontrar una entrada que produzca un hash dado) y resistencia a colisiones (que sea difícil encontrar dos entradas diferentes con el mismo hash).

MD5, SHA1, SHA256 y SHA512: diferencias reales

No todos los algoritmos hash son iguales. Estos cuatro son los más conocidos y, por compatibilidad, aún se ven mucho:

• MD5: salida de 128 bits (32 hex). Rápido, pero con colisiones conocidas. No se recomienda para seguridad.
• SHA1: 160 bits (40 hex). También tiene colisiones demostradas. Evitar para usos criptográficos.
• SHA256: 256 bits (64 hex). Estándar moderno para integridad y muchas firmas.
• SHA512: 512 bits (128 hex). Más largo; útil cuando se requiere mayor margen o compatibilidad con SHA-2.

Si el objetivo es verificar descargas o integridad, la recomendación práctica suele ser: SHA256 (o SHA512 si el proveedor lo publica así). Para contraseñas, en cambio, no basta con SHA256 “a secas”: necesitas funciones de derivación como bcrypt/Argon2. Lo explicamos en detalle en Hash vs cifrado y salting para contraseñas.

Cómo se representa un hash

El digest es binario, pero normalmente lo ves en texto como:

• Hexadecimal (lo más común): letras a-f y números.
• Base64: más compacto, típico en APIs.

Nuestro Generador de Hash te lo entrega en hexadecimal, porque es el formato que suelen publicar las páginas de descargas y documentación técnica.

Ejemplo rápido: verificar integridad

Supongamos que descargas un archivo y el sitio oficial publica un SHA256. El flujo correcto es:

1. Calcular el SHA256 del archivo en tu sistema.
2. Compararlo con el valor publicado.
3. Si coincide, el archivo no se corrompió en tránsito (y probablemente es el correcto).

En Windows, macOS y Linux puedes hacerlo con comandos nativos. Te dejo la guía paso a paso en: Cómo verificar el checksum SHA256 de un archivo.

Colisiones: el “talón de Aquiles”

Una colisión ocurre cuando dos entradas diferentes producen el mismo hash. En teoría, con suficiente esfuerzo siempre habrá colisiones (por el principio del palomar), pero la cuestión es si son prácticamente encontrables.

En MD5 y SHA1 ya hay técnicas conocidas para generar colisiones de forma realista, por eso no se recomiendan para firma, certificados o seguridad. Para integridad casual pueden seguir apareciendo por compatibilidad, pero si estás diseñando algo hoy, mejor apostar por SHA256/SHA512.

¿Entonces MD5 sirve para algo?

Sí, pero con matices. MD5 puede seguir siendo útil cuando:

• Necesitas compatibilidad con sistemas antiguos.
• Buscas una huella rápida para deduplicación o caché (no seguridad).
• Tu amenaza es “corrupción accidental”, no ataques deliberados.

En esos casos, puedes generar el valor en un clic con la herramienta: Generador de Hash (MD5, SHA1, SHA256, SHA512).

Buenas prácticas al trabajar con hashes

• Define el objetivo: integridad, identificación, seguridad… cada uno tiene algoritmos recomendados.
• Evita MD5/SHA1 si hay riesgo de adversario o si el hash se usa como prueba de autenticidad.
• No uses SHA “directo” para contraseñas: usa bcrypt/Argon2 + sal.
• Normaliza entradas si comparas texto (por ejemplo saltos de línea). Nuestra herramienta incluye esa opción.

Preguntas frecuentes

¿Un hash garantiza que el archivo es “oficial”?

Un hash garantiza que el archivo coincide con el que se usó para publicar ese checksum. Pero si el sitio que publica el hash fue comprometido, podrían darte archivo y hash maliciosos a la vez. Para autenticidad fuerte se usan firmas (GPG, certificados, etc.). Si te interesa el enfoque DevOps, mira Checksums y firmas en DevOps.

¿Por qué el mismo texto da hashes diferentes en distintos sitios?

Normalmente por diferencias invisibles: espacios finales, codificación, o saltos de línea (CRLF vs LF). Por eso conviene normalizar. En el generador de hash puedes convertir saltos a LF para comparar con herramientas de Linux.

Prueba tú mismo

Para cerrar, haz este experimento: calcula el SHA256 de la frase “hola mundo” y luego de “hola mundo ” (con un espacio al final). Verás que el resultado cambia por completo. Esa sensibilidad es lo que hace al hash tan útil para integridad y detección de cambios.

Cuando quieras generar o comparar valores rápido, vuelve al Generador de Hash (MD5, SHA1, SHA256, SHA512).

Tabla rápida: longitud del hash en hexadecimal

Una forma práctica de reconocer el algoritmo es mirar la longitud del digest en hexadecimal. No es una “prueba”, pero ayuda a orientarte cuando revisas logs o documentación.

Hashes en APIs: firmas, idempotencia y depuración

En integraciones es frecuente firmar peticiones con un hash del payload o de campos concatenados. Por ejemplo, algunos proveedores piden calcular un digest de timestamp + body + secret y enviarlo como cabecera. Esto no es “magia”: es una manera de que el servidor detecte modificaciones en tránsito.

Cuando algo falla, el trabajo de QA suele ser comparar el valor que genera tu código con el que espera el proveedor. Ahí un generador como este ayuda mucho: puedes copiar la concatenación exacta y validar el resultado sin tocar código. Úsalo aquí: Generador de Hash (MD5, SHA1, SHA256, SHA512).

Otro uso típico es la idempotencia: crear un identificador estable de una operación (por ejemplo, un alta de usuario) a partir de los datos relevantes. Si el cliente reintenta, el servidor puede reconocer que ya procesó “la misma” operación. En esos casos, el hash funciona como huella de la petición. Ojo: si lo usas como clave de negocio, define bien qué campos entran en el digest y cómo se normalizan.

Hash de texto vs hash de archivo

Un error común es mezclar conceptos: calcular un hash de un texto copiado desde una web no es lo mismo que calcular el hash del archivo descargado. Para integridad, lo correcto es hashear el archivo (sus bytes exactos). Para depuración de integraciones, normalmente hasheas el texto o JSON (ojo con espacios y saltos de línea).

Si tu objetivo es un fichero (por ejemplo un instalador), sigue la guía de comandos: verificar checksum SHA256. Si necesitas hashear un fragmento de texto (por ejemplo un token o el cuerpo de una petición), usa el generador online.

Recomendación final (regla fácil)

Si estás en dudas, usa esta regla rápida: SHA256 para integridad general, SHA512 si el estándar del proyecto lo pide, y evita MD5/SHA1 salvo por compatibilidad. Y si hablamos de contraseñas, no uses ninguno de estos directamente: ve a Argon2/bcrypt.

Mini-ejercicio: comprobar que dos textos son idénticos

Imagina que un compañero te pasa por chat un bloque de configuración (Nginx, Apache, JSON, lo que sea) y te dice: “es el mismo que ayer”. A simple vista puede parecer igual, pero un espacio o una coma cambian el comportamiento. En vez de comparar línea por línea, pueden acordar calcular un hash del contenido.

1. Ambos pegan el texto en el generador de hash.
2. Seleccionan el mismo algoritmo (por ejemplo SHA256) y normalizan saltos de línea a LF.
3. Si el digest coincide, el contenido es idéntico (byte a byte tras la normalización).

Es una técnica simple que ahorra tiempo en debugging, especialmente cuando el cambio es invisible en un editor (caracteres raros, tabulaciones, saltos distintos, etc.).

¿Por qué existen tantos algoritmos?

Porque los requisitos cambian con el tiempo. A medida que aparecen nuevas técnicas de ataque y aumenta la potencia de cómputo, algunos algoritmos quedan obsoletos para seguridad. Por eso hoy se recomiendan SHA-2 (SHA256/SHA512) y, en otros contextos, familias como SHA-3. En portales y documentación, de todas formas, es normal ver MD5 o SHA1 por compatibilidad histórica.