Qué es un hash, checksums y SHA-256 en la práctica

Qué es una función hash

Una función hash transforma un input de cualquier tamaño (un texto, un archivo entero, una cadena de bytes) en una salida de tamaño fijo, normalmente expresada como una secuencia hexadecimal corta. Las propiedades clave son cuatro: el mismo input siempre produce el mismo output; un cambio mínimo en el input cambia drásticamente el output; el output no permite recuperar el input; y encontrar dos inputs distintos con el mismo output debe ser computacionalmente inviable (resistencia a colisiones).

Esas propiedades hacen que el hash sirva como huella digital corta de un dato cualquiera. Si un fabricante publica SHA-256: abc123... junto a su archivo, cualquiera que descargue el archivo puede recalcular el hash localmente y verificar que coincide. Si coincide, el archivo es bit a bit el que el fabricante publicó. Si no, ha sido modificado, corrompido o sustituido.

Los algoritmos hash más usados hoy son la familia SHA-2 (SHA-256, SHA-384, SHA-512), publicada por NIST en 2001 y aún considerada segura para integridad y firma digital. MD5 (1992) y SHA-1 (1995) siguen vivos por compatibilidad histórica pero ya no son aptos para casos donde un atacante puede manipular el input.

Hash vs checksum

Los términos suelen usarse como sinónimos pero no son exactamente lo mismo. Un “checksum” es cualquier función que produce una huella de un bloque de datos para detectar errores de transmisión o de almacenamiento. Las primeras CRCs (CRC-16, CRC-32) son checksums diseñados para captar bit-flips accidentales en redes o discos; son rápidos, baratos y nunca pretendieron ser resistentes a un atacante. Si dos archivos colisionan en CRC-32, no es una sorpresa.

Una función hash criptográfica es un tipo concreto de checksum que añade resistencia frente a colisiones intencionales. SHA-256 no solo detecta corrupción accidental, también resiste el escenario en el que alguien busca activamente otro contenido con el mismo hash. Esa propiedad es lo que separa “verificar que el archivo no se rompió” de “verificar que nadie sustituyó el archivo por uno alterado”.

En la práctica, cuando un proyecto publica un archivo SHA256SUMSo un campo “Checksum (SHA-256)” en su página de descarga, está usando un hash criptográfico como checksum. Esa es la mezcla habitual: en una página web, “checksum” suele referirse a SHA-256 o SHA-512 incluso aunque el término técnico abarque cosas más débiles como CRC.

SHA-256, SHA-1, SHA-512 y MD5: cuándo usar cada uno

La calculadora soporta cinco algoritmos. La elección depende de la sensibilidad del caso de uso.

Como regla por defecto: SHA-256 para integridad y firma; SHA-512 cuando el sistema receptor lo pide; SHA-1 solo en sistemas legacy concretos (Git); MD5 solo para checksums de bajo riesgo donde nadie va a manipular el archivo. Para passwords, ninguna; usa una librería real de password hashing.

Cómo verificar una descarga con SHA-256

El caso de uso clásico es comprobar que la ISO de una distribución Linux que has descargado coincide con la que el proyecto publica. Tres pasos:

1. En la página oficial de descargas, busca el SHA-256 publicado. Suele aparecer junto al enlace de la ISO o en un archivo aparte llamado SHA256SUMS o similar. Cópialo entero.
2. Calcula el SHA-256 de tu archivo local. En esta página: arrastra el archivo a la zona de file hashing, selecciona SHA-256 y espera. En terminal Linux/macOS: sha256sum mi-archivo.iso. En PowerShell: Get-FileHash -Algorithm SHA256 mi-archivo.iso.
3. Pega el hash publicado en el campo “Hash esperado” de la calculadora (o compara visualmente). La calculadora ignora espacios y mayúsculas, así que da igual si el fabricante publica el hash en mayúsculas y la herramienta lo emite en minúsculas.

Si los dos hashes coinciden, el archivo es bit a bit el que el fabricante publicó. Si no coinciden, el archivo está corrompido, modificado o has elegido un algoritmo distinto al que publicó el fabricante (por ejemplo, has calculado SHA-512 pero el sitio publica SHA-256).

Una advertencia importante: el SHA-256 publicado por el fabricante solo es fiable si confías en la página donde lo lees. Si un atacante controla la página de descargas, también controla el hash publicado. Para casos donde esto importa, los proyectos publican adicionalmente firmas GPG del archivo SHA256SUMS. Una buena heurística: si los hashes están en la misma página y bajo el mismo control que la descarga, sirven para detectar corrupción accidental; para protección frente a un atacante, se necesita firma criptográfica sobre el hash, no solo el hash.

Por qué MD5 está roto pero aún aparece en descargas antiguas

MD5 fue publicado en 1992 y se usó masivamente durante más de una década. El problema llegó cuando los investigadores demostraron, primero en teoría y luego en práctica, que era posible generar deliberadamente dos archivos distintos con el mismo MD5. En 2008 ya había demostraciones de colisión en minutos sobre hardware doméstico; hoy se puede hacer en segundos.

Eso significa que MD5 falla la propiedad clave de un hash criptográfico: resistencia a colisiones intencionales. Sigue valiendo para detectar que un archivo se ha corrompido por un bit-flip al copiarlo de un disco viejo o por error de red, porque en ese caso nadie está buscando una colisión: el bit-flip es aleatorio. Pero no vale para detectar manipulación maliciosa: alguien puede sustituir el archivo original por otro con el mismo MD5 y la verificación pasaría.

Sigue apareciendo en descargas antiguas, en sumarios de mirror de paquetes legacy o en hashes incrustados en código viejo. La calculadora lo soporta porque hay casos legítimos para comprobar checksums de bajo riesgo, pero la UI marca el algoritmo como LEGACY y todas las recomendaciones empujan a SHA-256.

Por qué no debes usar SHA-256 ni MD5 para passwords

Los hashes simples (MD5, SHA-1, SHA-256, SHA-384, SHA-512) están diseñados para ser muy rápidos. Esa velocidad es exactamente lo que se quiere para verificar checksums de archivos: calcular SHA-256 de un .iso de 4 GB debe tardar segundos, no horas. Pero esa misma velocidad es lo que los hace inadecuados para almacenar passwords.

Cuando un atacante consigue una base de datos con passwords hasheados con SHA-256, puede probar miles de millones de combinaciones por segundo sobre hardware moderno (GPUs, ASICs especializados). En cuestión de horas o días tiene todos los passwords débiles de la base. Añadir un salt mitiga ataques con tablas precomputadas (rainbow tables) pero no detiene el ataque directo a fuerza bruta.

Las funciones diseñadas para password hashing aplican dos mecanismos extra: salt obligatorio (distinto por usuario, evita rainbow tables) y un factor de coste deliberado que hace que cada intento individual tarde milisegundos en lugar de nanosegundos. Eso reduce el ritmo del atacante de miles de millones por segundo a cientos por segundo, lo que cambia el cálculo de viabilidad.

Las tres familias estándar son:

• bcrypt: estándar veterano, factor de coste configurable, salt automático.
• scrypt: añade coste de memoria para resistir ataques con GPUs.
• argon2: ganador del Password Hashing Competition de 2015, considerado el estándar actual.

Estas funciones no están en esta calculadora porque su uso correcto implica decisiones operativas (parámetros, almacenamiento del salt, manejo de versiones) que pertenecen al backend que almacena los passwords, no a una herramienta interactiva de propósito general. La regla práctica para la calculadora: si lo que estás hasheando es un password, no estás en el sitio correcto.

Errores comunes

• Confundir codificación con algoritmo. El mismo hash se puede expresar en hex (default, 64 caracteres para SHA-256), base64 (44 caracteres con padding) o cualquier otra codificación binaria. Cambiar la codificación no cambia el hash subyacente: es el mismo número, escrito distinto. Si tu verificación falla porque “los strings son distintos”, comprueba que ambos lados estén usando la misma codificación antes de buscar manipulación.
• Comparar hashes con mayúsculas distintas. El hex es case-insensitive por convención. ABC123 y abc123 son el mismo hash. La calculadora compara ignorando mayúsculas, pero un diff ingenuo en shell sí distingue. Normaliza antes de comparar.
• Olvidar espacios y saltos de línea. Un comando shell tipo echo “hola” | sha256sum añade un salto de línea al final, así que el hash es de “hola\n”, no de “hola”. Para hashear exactamente la cadena, usa printf “hola” | sha256sum o pega la cadena en la calculadora sin saltos de línea finales.
• Esperar que el hash sea reversible. Una función hash NO es cifrado: no hay forma matemática de recuperar el input desde el output. Las páginas que afirman “decode hash” en realidad solo buscan en bases de datos de inputs comunes precomputados. Para datos no triviales no funcionan.
• Tratar la colisión de MD5 como problema teórico. Las colisiones MD5 se generan en hardware doméstico en segundos. Cualquier proceso de seguridad que confíe en MD5 frente a un atacante está roto en la práctica, no solo “en teoría”.

Cómo usar la calculadora

La calculadora de hash y checksum acepta texto pegado o archivos arrastrados, soporta SHA-256, SHA-1, SHA-384, SHA-512 y MD5, y devuelve el resultado en hex (default) o base64. Tiene además un campo “Hash esperado” para comparar contra el hash publicado por el fabricante. Todo el cálculo ocurre en tu navegador: los SHA-* se computan con Web Crypto API y MD5 con JavaScript local. Ningún texto, archivo ni checksum esperado se envía a un servidor.

Casos de uso típicos: verificar una ISO antes de instalarla, generar un identificador estable a partir de una cadena para usarlo como clave en código, comprobar que un archivo no ha cambiado entre dos copias, calcular el hash que un sistema externo te exige introducir manualmente.

Para passwords sigue valiendo lo mismo de antes: usa una librería real de password hashing (bcrypt, scrypt, argon2), no esta calculadora. La calculadora es para integridad y verificación de contenido, no para autenticación.