¿Qué es SHA-256?
SHA-256 forma parte de la familia SHA-2 de funciones hash criptográficas, estandarizada por el NIST (el instituto de normalización de Estados Unidos). Recibe un mensaje de cualquier longitud y genera un digest fijo de 256 bits (32 bytes), que aquí se muestra como 64 caracteres hexadecimales. La misma entrada produce siempre el mismo digest, mientras que cambiar un solo carácter genera un resultado completamente distinto: es lo que se conoce como efecto avalancha. SHA-256 se utiliza de forma generalizada en certificados TLS, firmas digitales, cadenas de bloques (Bitcoin) y comprobaciones de integridad de archivos.
Cómo usar esta calculadora
Escribe o pega cualquier texto en el cuadro de entrada y pulsa enviar. La calculadora codifica tu texto en UTF-8, ejecuta el algoritmo SHA-256 y devuelve el digest en hexadecimal junto con la longitud en bytes de la entrada. Dejar el campo vacío también es válido: en ese caso obtendrás el conocido digest de la cadena vacía.
La fórmula al detalle
$$\text{Hash} = \operatorname{SHA\text{-}256}\!\left(\text{Input Text}\right)$$
SHA-256 rellena el mensaje (padding) hasta que su longitud sea múltiplo de 512 bits, lo divide en bloques de 512 bits y procesa cada bloque a través de 64 rondas de operaciones a nivel de bits (rotaciones, desplazamientos, AND/XOR y suma modular) que mezclan ocho variables de trabajo de 32 bits, inicializadas a partir de las partes fraccionarias de las raíces cuadradas de números primos. Tras cada bloque, los ocho registros se suman de nuevo al estado acumulado del hash; al concatenarlos se obtiene el digest final de 256 bits.
Ejemplo práctico
La entrada abc (3 bytes) produce el digest ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad. La cadena vacía produce e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855, un vector de prueba estándar.
Constantes SHA-256 y valores hash iniciales
SHA-256 forma parte de la familia SHA-2 estandarizada por NIST en FIPS 180-4. Trabaja con palabras de 32 bits, procesa el mensaje en bloques de 512 bits y añade la longitud del mensaje como un entero de 64 bits en formato big-endian. Todas las sumas se realizan módulo \(2^{32}\).
Valores hash iniciales H0–H7
Los ocho valores iniciales son los primeros 32 bits de las partes fraccionarias de las raíces cuadradas de los primeros ocho números primos (2, 3, 5, 7, 11, 13, 17, 19):
| Registro | Primo | Valor inicial (hex) |
|---|---|---|
| H0 | 2 | 6a09e667 |
| H1 | 3 | bb67ae85 |
| H2 | 5 | 3c6ef372 |
| H3 | 7 | a54ff53a |
| H4 | 11 | 510e527f |
| H5 | 13 | 9b05688c |
| H6 | 17 | 1f83d9ab |
| H7 | 19 | 5be0cd19 |
Formalmente, para el primo \(p_i\): $$H_i = \left\lfloor \left(\sqrt{p_i} - \lfloor \sqrt{p_i} \rfloor\right) \cdot 2^{32} \right\rfloor$$ Por ejemplo, \(\sqrt{2} \approx 1.41421356\), y su parte fraccionaria multiplicada por \(2^{32}\) da 0x6a09e667.
Constantes de ronda K0–K63
Las 64 constantes de ronda se derivan de la misma manera, pero a partir de las raíces cúbicas de los primeros 64 números primos (del 2 al 311): $$K_t = \left\lfloor \left(\sqrt[3]{p_t} - \lfloor \sqrt[3]{p_t} \rfloor\right) \cdot 2^{32} \right\rfloor$$ Las primeras son 428a2f98, 71374491, b5c0fbcf y e9b5dba5. Como provienen de una fórmula transparente y no de elecciones arbitrarias, son números de tipo "nothing-up-my-sleeve" (sin trampa oculta).
Parámetros de tamaño
- Tamaño de palabra: 32 bits
- Tamaño de bloque: 512 bits (64 bytes, 16 palabras)
- Campo de longitud: 64 bits, añadido al final del mensaje rellenado
- Salida: 256 bits, mostrados como 64 caracteres hexadecimales
Cómo se calcula SHA-256 paso a paso
- Codificar la entrada en UTF-8. El texto se convierte en bytes. Los caracteres ASCII ocupan 1 byte cada uno, mientras que otros caracteres ocupan de 2 a 4 bytes. El hash se calcula sobre estos bytes, no sobre los caracteres.
- Rellenar el mensaje. Añadir un único bit 1 (el byte 0x80) y luego bits 0 hasta que la longitud sea 448 mod 512. Finalmente, añadir la longitud original del mensaje en bits como un entero de 64 bits en formato big-endian.
- Dividir en bloques de 512 bits. Cada bloque se lee como dieciséis palabras de 32 bits big-endian \(W_0 \dots W_{15}\).
- Construir el programa de mensajes. Para \(16 \le t < 64\): $$W_t = \sigma_1(W_{t-2}) + W_{t-7} + \sigma_0(W_{t-15}) + W_{t-16}$$ donde \(\sigma_0(x) = \text{ROTR}^7(x) \oplus \text{ROTR}^{18}(x) \oplus \text{SHR}^3(x)\) y \(\sigma_1(x) = \text{ROTR}^{17}(x) \oplus \text{ROTR}^{19}(x) \oplus \text{SHR}^{10}(x)\).
- Ejecutar 64 rondas de compresión. Iniciar las variables de trabajo a–h con el estado actual del hash. En cada ronda calcular $$T_1 = h + \Sigma_1(e) + \text{Ch}(e,f,g) + K_t + W_t,\quad T_2 = \Sigma_0(a) + \text{Maj}(a,b,c)$$ con \(\text{Ch}(e,f,g) = (e \wedge f) \oplus (\lnot e \wedge g)\), \(\text{Maj}(a,b,c) = (a \wedge b) \oplus (a \wedge c) \oplus (b \wedge c)\), \(\Sigma_0(a) = \text{ROTR}^2 \oplus \text{ROTR}^{13} \oplus \text{ROTR}^{22}\) y \(\Sigma_1(e) = \text{ROTR}^6 \oplus \text{ROTR}^{11} \oplus \text{ROTR}^{25}\). Después desplazar las variables: h←g, g←f, f←e, e←d+T1, d←c, c←b, b←a, a←T1+T2.
- Actualizar el estado del hash. Sumar a–h a H0–H7 (mód \(2^{32}\)). Repetir los pasos 4–6 para cada bloque adicional.
- Generar el resumen. Concatenar H0 a H7, cada uno con 8 dígitos hexadecimales, lo que da 64 caracteres hexadecimales.
Ejemplo de relleno: "abc"
La entrada "abc" son los 3 bytes 0x61 0x62 0x63, que equivalen a 24 bits. Después del relleno:
- Bytes del mensaje:
61 62 63(24 bits) - Añadir
80(el bit 1 seguido de siete bits 0); la longitud es ahora de 32 bits - Añadir 52 bytes cero para que la longitud llegue a 448 bits (24 + 1 + 423 bits cero)
- Añadir la longitud de 64 bits:
00 00 00 00 00 00 00 18, ya que 24 = 0x18
Total: 3 + 1 + 52 + 8 = 64 bytes = 512 bits, así que basta con un bloque.
Comparación de resúmenes SHA-256 entre entradas
Independientemente de la longitud de la entrada, el resumen SHA-256 siempre tiene 256 bits, o 64 caracteres hexadecimales. Cambiar incluso un solo carácter produce un resumen completamente distinto (el efecto avalancha). Solo se muestran abajo los resúmenes de los que tengo certeza; para los demás, introduce el texto en la calculadora para ver el resultado.
| Entrada | Caracteres | Bytes UTF-8 | Resumen SHA-256 |
|---|---|---|---|
| (cadena vacía) | 0 | 0 | e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 |
| abc | 3 | 3 | ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad |
| Abc | 3 | 3 | Resumen no relacionado de 64 caracteres; introdúcelo en la calculadora para verlo |
| é | 1 | 2 (0xC3 0xA9) | Resumen de 64 caracteres de los 2 bytes UTF-8; introdúcelo en la calculadora para verlo |
Qué muestra la tabla
- Efecto avalancha: "abc" y "Abc" difieren en un solo bit (0x61 frente a 0x41 en el primer byte), y sin embargo sus resúmenes no comparten ninguna similitud significativa. Aproximadamente la mitad de los bits de salida cambian.
- Caracteres frente a bytes: "é" es un carácter, pero dos bytes en UTF-8, así que el hash se calcula sobre 2 bytes. El mismo carácter visible puede codificarse de forma distinta (por ejemplo, una é precompuesta frente a una "e" más un acento combinante), y estas codificaciones dan resúmenes diferentes.
- Longitud fija: la cadena vacía y un documento largo dan ambos 64 caracteres hexadecimales.
Preguntas frecuentes
¿Se puede revertir SHA-256? No. Es una función unidireccional: no es posible recuperar la entrada a partir del digest.
¿Por qué mi recuento de bytes es mayor que el de caracteres? Los caracteres que no son ASCII (acentos, emojis, caracteres CJK) ocupan varios bytes en UTF-8, así que la longitud en bytes puede superar el número de caracteres.
¿Sigue siendo seguro SHA-256? Sí. A día de hoy no existen ataques prácticos de colisión ni de preimagen contra SHA-256, por lo que sigue siendo una función hash recomendada para uso general.