Remolino (función hash)

La versión original de Whirlpool se llamará Whirlpool-0 , la primera revisión de Whirlpool se llamará Whirlpool-T y la última versión se llamará Whirlpool en los siguientes vectores de prueba.

• En la primera revisión de 2001, la caja S se modificó, pasando de ser una generada aleatoriamente con buenas propiedades criptográficas a una que posee mejores propiedades criptográficas y es más fácil de implementar en hardware.
• En la segunda revisión (2003), se encontró un fallo en la matriz de difusión que redujo la seguridad estimada del algoritmo por debajo de su potencial. ^{[ 4 ]} Cambiar las constantes de la matriz rotatoria de 8x8 de (1, 1, 3, 1, 5, 8, 9, 5) a (1, 1, 4, 1, 8, 5, 2, 9) resolvió este problema.

La operación SubBytes aplica una permutación no lineal (la caja S) a cada byte del estado de forma independiente. La caja S de 8 bits se compone de 3 cajas S más pequeñas de 4 bits.

La operación ShiftColumns desplaza cíclicamente cada byte en cada columna del estado. Los bytes de la columna j se desplazan hacia abajo j posiciones.

La operación MixBytesInRows es una multiplicación derecha de cada fila por una matriz de 8×8 sobre${\displaystyle GF({2^{8}})}$La matriz se elige de tal manera que el número de ramas (una propiedad importante al considerar la resistencia al criptoanálisis diferencial ) sea 9, que es el máximo.

La operación AddRoundKey utiliza la operación XOR bit a bit para añadir una clave calculada mediante la programación de claves al estado actual. La programación de claves es idéntica al cifrado en sí, salvo que la función AddRoundKey se sustituye por una función AddRoundConstant que añade una constante predeterminada en cada ronda.

El mensaje${\displaystyle M}$La cadena que se va a hashear primero se rellena para asegurar que su longitud sea un múltiplo del tamaño del bloque (512 bits). Esto se hace utilizando el esquema de relleno estándar definido en la norma ISO/IEC 10118-1 (el mismo que se usa para md5 , sha-2 y otros):

1. Añadir un bit '1';
2. Agregue tantos bits '0' como sean necesarios para que la longitud alcance un múltiplo de 256 (${\displaystyle 512-256}$);
3. Agregue la longitud original del mensaje en bits utilizando el formato big-endian de 256 bits .

Luego, el mensaje relleno se divide en${\displaystyle t}$bloques de 512 bits${\displaystyle m_{i}}$,${\displaystyle 1\leq i\leq t}$.

Whirlpool itera el esquema de hash de Miyaguchi-Preneel sobre estos bloques ^{[secciones 3.11 y 3.12] [ 1 ]} :

${\displaystyle {\begin{aligned}&{\begin{aligned}\eta _{i}&=\mu \left(m_{i}\right),\\H_{0}&=\mu \left(IV\right),\\H_{i}&=W\left[H_{i-1}\right]\left(\eta _{i}\right)\oplus H_{i-1}\oplus \eta _{i},\ 1\leq i\leq t\\\end{aligned}}\\&{\text{Whirlpool}}\left(M\right)\equiv \mu ^{-1}\left(H_{t}\right)\end{aligned}}}$

Dónde:

• ${\displaystyle \mu$ :\{0,1\}^{512}\to {\mathcal {M}}_{8\times 8}} es lafunción de conversión de cadena a matriz ;
• ${\displaystyle \mu ^{-1}:{\mathcal {M}}_{8\times 8}\to \{0,1\}^{512}}$es la función de conversión de matriz a cadena ;
• ${\displaystyle IV}$es el vector de inicialización , una cadena de 512 bits 0;
• ${\displaystyle W}$es la función de cifrado Whirlpool.

La función de cifrado de bloques interna${\displaystyle W\left[{\mathcal {M}}_{8\times 8}\right]:{\mathcal {M}}_{8\times 8}\to {\mathcal {M}}_{8\times 8}}$^{[sección 3.9] [ 1 ]} opera sobre una matriz de 8x8 y devuelve una matriz de 8x8 :

${\displaystyle {\begin{aligned}W\left[K\right]=\left({\underset {1}{\overset {r=R}{\bigcirc }}}\rho \left[K_{r}\right]\right)\circ \sigma \left[K_{0}\right]\end{aligned}}}$

Dónde:

• ${\displaystyle R}$es el número de rondas (el estándar Whirlpool utiliza${\displaystyle R=10}$);
• ${\displaystyle K_{n}}$es la enésima clave de la${\displaystyle K}$cronograma clave;
• ${\displaystyle \rho }$es la función redonda.

El cronograma clave amplía el cronograma clave${\displaystyle K\in {\mathcal {M}}_{8\times 8}}$en una secuencia de teclas${\displaystyle K_{r}\in {\mathcal {M}}_{8\times 8},\ 0\leq r\leq R}$^{[sección 3.8] [ 1 ]} :

${\displaystyle {\begin{aligned}K_{0}&=K,\\K_{r}&=\rho \left[c^{r}\right]\left(K_{r-1}\right),\ 1\leq r\leq R\\\end{aligned}}}$

Dónde:

• ${\displaystyle c^{r}\in {\mathcal {M}}_{8\times 8}}$es la matriz constante de la r-ésima ronda .

La constante redonda para la r-ésima ronda,${\displaystyle r>0}$, es una matriz${\displaystyle c^{r}\in {\mathcal {M}}_{8\times 8}}$, definido como:

${\displaystyle {\begin{aligned}c_{0,j}^{r}&=S\left[8\left(r-1\right)+j\right],&0\leq j<8\\c_{i,j}^{r}&=0,&1\leq i<8,0\leq j<8\\\end{aligned}}}$

Dónde:

• ${\displaystyle S\in {\mathcal {M}}_{16\times 16}}$es la caja S.

La función redonda${\displaystyle \rho \left[{\mathcal {M}}_{8\times 8}\right]:{\mathcal {M}}_{8\times 8}\to {\mathcal {M}}_{8\times 8}}$^{[sección 3.7] [ 1 ]} se define como:

${\displaystyle {\begin{aligned}\rho \left[k\right]&=\sigma \left[k\right]\circ \theta \circ \pi \circ \gamma \\&_{\left(=\ AK\ \circ \ MR\ \circ \ SC\ \circ \ SB\right)}\\\end{aligned}}}$

Dónde:

• ${\displaystyle \gamma }$es la capa no lineal;
• ${\displaystyle \pi }$es la permutación cíclica ;
• ${\displaystyle \theta }$es la capa de difusión;
• ${\displaystyle \sigma }$es la adición clave.

La caja S${\displaystyle S\in {\mathcal {M}}_{16\times 16}}$Normalmente se representa como una tabla de búsqueda , donde cada byte de entrada se asigna a un byte de salida correspondiente . Se puede calcular utilizando técnicas de generación de mapeo de difusión óptimo ^{[sección 2.4] [ 1 ]} , pero aquí se muestra una representación matricial :${\displaystyle {\begin{aligned}&S={\begin{pmatrix}18_{(16)}&23_{(16)}&c6_{(16)}&e8_{(16)}&87_{(16)}&b8_{(16)}&01_{(16)}&4f_{(16)}&36_{(16)}&a6_{(16)}&d2_{(16)}&f5_{(16)}&79_{(16)}&6f_{(16)}&91_{(16)}&52_{(16)}\\60_{(16)}&bc_{(16)}&9b_{(16)}&8e_{(16)}&a3_{(16)}&0c_{(16)}&7b_{(16)}&35_{(16)}&1d_{(16)}&e0_{(16)}&d7_{(16)}&c2_{(16)}&2e_{(16)}&4b_{(16)}&fe_{(16)}&57_{(16)}\\15_{(16)}&77_{(16)}&37_{(16)}&e5_{(16)}&9f_{(16)}&f0_{(16)}&4a_{(16)}&da_{(16)}&58_{(16)}&c9_{(16)}&29_{(16)}&0a_{(16)}&b1_{(16)}&a0_{(16)}&6b_{(16)}&85_{(16)}\\bd_{(16)}&5d_{(16)}&10_{(16)}&f4_{(16)}&cb_{(16)}&3e_{(16)}&05_{(16)}&67_{(16)}&e4_{(16)}&27_{(16)}&41_{(16)}&8b_{(16)}&a7_{(16)}&7d_{(16)}&95_{(16)}&d8_{(16)}\\fb_{(16)}&ee_{(16)}&7c_{(16)}&66_{(16)}&dd_{(16)}&17_{(16)}&47_{(16)}&9e_{(16)}&ca_{(16)}&2d_{(16)}&bf_{(16)}&07_{(16)}&ad_{(16)}&5a_{(16)}&83_{(16)}&33_{(16)}\\63_{(16)}&02_{(16)}&aa_{(16)}&71_{(16)}&c8_{(16)}&19_{(16)}&49_{(16)}&d9_{(16)}&f2_{(16)}&e3_{(16)}&5b_{(16)}&88_{(16)}&9a_{(16)}&26_{(16)}&32_{(16)}&b0_{(16)}\\e9_{(16)}&0f_{(16)}&d5_{(16)}&80_{(16)}&be_{(16)}&cd_{(16)}&34_{(16)}&48_{(16)}&ff_{(16)}&7a_{(16)}&90_{(16)}&5f_{(16)}&20_{(16)}&68_{(16)}&1a_{(16)}&ae_{(16)}\\b4_{(16)}&54_{(16)}&93_{(16)}&22_{(16)}&64_{(16)}&f1_{(16)}&73_{(16)}&12_{(16)}&40_{(16)}&08_{(16)}&c3_{(16)}&ec_{(16)}&db_{(16)}&a1_{(16)}&8d_{(16)}&3d_{(16)}\\97_{(16)}&00_{(16)}&cf_{(16)}&2b_{(16)}&76_{(16)}&82_{(16)}&d6_{(16)}&1b_{(16)}&b5_{(16)}&af_{(16)}&6a_{(16)}&50_{(16)}&45_{(16)}&f3_{(16)}&30_{(16)}&ef_{(16)}\\3f_{(16)}&55_{(16)}&a2_{(16)}&ea_{(16)}&65_{(16)}&ba_{(16)}&2f_{(16)}&c0_{(16)}&de_{(16)}&1c_{(16)}&fd_{(16)}&4d_{(16)}&92_{(16)}&75_{(16)}&06_{(16)}&8a_{(16)}\\b2_{(16)}&e6_{(16)}&0e_{(16)}&1f_{(16)}&62_{(16)}&d4_{(16)}&a8_{(16)}&96_{(16)}&f9_{(16)}&c5_{(16)}&25_{(16)}&59_{(16)}&84_{(16)}&72_{(16)}&39_{(16)}&4c_{(16)}\\5e_{(16)}&78_{(16)}&38_{(16)}&8c_{(16)}&d1_{(16)}&a5_{(16)}&e2_{(16)}&61_{(16)}&b3_{(16)}&21_{(16)}&9c_{(16)}&1e_{(16)}&43_{(16)}&c7_{(16)}&fc_{(16)}&04_{(16)}\\51_{(16)}&99_{(16)}&6d_{(16)}&0d_{(16)}&fa_{(16)}&df_{(16)}&7e_{(16)}&24_{(16)}&3b_{(16)}&ab_{(16)}&ce_{(16)}&11_{(16)}&8f_{(16)}&4e_{(16)}&b7_{(16)}&eb_{(16)}\\3c_{(16)}&81_{(16)}&94_{(16)}&f7_{(16)}&b9_{(16)}&13_{(16)}&2c_{(16)}&d3_{(16)}&e7_{(16)}&6e_{(16)}&c4_{(16)}&03_{(16)}&56_{(16)}&44_{(16)}&7f_{(16)}&a9_{(16)}\\2a_{(16)}&bb_{(16)}&c1_{(16)}&53_{(16)}&dc_{(16)}&0b_{(16)}&9d_{(16)}&6c_{(16)}&31_{(16)}&74_{(16)}&f6_{(16)}&46_{(16)}&ac_{(16)}&89_{(16)}&14_{(16)}&e1_{(16)}\\16_{(16)}&3a_{(16)}&69_{(16)}&09_{(16)}&70_{(16)}&b6_{(16)}&d0_{(16)}&ed_{(16)}&cc_{(16)}&42_{(16)}&98_{(16)}&a4_{(16)}&28_{(16)}&5c_{(16)}&f8_{(16)}&86_{(16)}\\\end{pmatrix}}\\\end{aligned}}}$

Aquí se muestra un ejemplo de implementación del algoritmo estándar de Whirlpool :

S := 0x18, 0x23, 0xc6, 0xe8, 0x87, 0xb8, 0x01, 0x4f, 0x36, 0xa6, 0xd2, 0xf5, 0x79, 0x6f, 0x91, 0x52, \ 0x60, 0xbc, 0x9b, 0x8e, 0xa3, 0x0c, 0x7b, 0x35, 0x1d, 0xe0, 0xd7, 0xc2, 0x2e, 0x4b, 0xfe, 0x57, \ 0x15, 0x77, 0x37, 0xe5, 0x9f, 0xf0, 0x4a, 0xda, 0x58, 0xc9, 0x29, 0x0a, 0xb1, 0xa0, 0x6b, 0x85, \ 0xbd, 0x5d, 0x10, 0xf4, 0xcb, 0x3e, 0x05, 0x67, 0xe4, 0x27, 0x41, 0x8b, 0xa7, 0x7d, 0x95, 0xd8, \ 0xfb, 0xee, 0x7c, 0x66, 0xdd, 0x17, 0x47, 0x9e, 0xca, 0x2d, 0xbf, 0x07, 0xad, 0x5a, 0x83, 0x33, \ 0x63, 0x02, 0xaa, 0x71, 0xc8, 0x19, 0x49, 0xd9, 0xf2, 0xe3, 0x5b, 0x88, 0x9a, 0x26, 0x32, 0xb0, \ 0xe9, 0x0f, 0xd5, 0x80, 0xbe, 0xcd, 0x34, 0x48, 0xff, 0x7a, 0x90, 0x5f, 0x20, 0x68, 0x1a, 0xae, \ 0xb4, 0x54, 0x93, 0x22, 0x64, 0xf1, 0x73, 0x12, 0x40, 0x08, 0xc3, 0xec, 0xdb, 0xa1, 0x8d, 0x3d, \ 0x97, 0x00, 0xcf, 0x2b, 0x76, 0x82, 0xd6, 0x1b, 0xb5, 0xaf, 0x6a, 0x50, 0x45, 0xf3, 0x30, 0xef, \ 0x3f, 0x55, 0xa2, 0xea, 0x65, 0xba, 0x2f, 0xc0, 0xde, 0x1c, 0xfd, 0x4d, 0x92, 0x75, 0x06, 0x8a, \ 0xb2, 0xe6, 0x0e, 0x1f, 0x62, 0xd4, 0xa8, 0x96, 0xf9, 0xc5, 0x25, 0x59, 0x84, 0x72, 0x39, 0x4c, \ 0x5e, 0x78, 0x38, 0x8c, 0xd1, 0xa5, 0xe2, 0x61, 0xb3, 0x21, 0x9c, 0x1e, 0x43, 0xc7, 0xfc, 0x04, \ 0x51, 0x99, 0x6d, 0x0d, 0xfa, 0xdf, 0x7e, 0x24, 0x3b, 0xab, 0xce, 0x11, 0x8f, 0x4e, 0xb7, 0xeb, \ 0x3c, 0x81, 0x94, 0xf7, 0xb9, 0x13, 0x2c, 0xd3, 0xe7, 0x6e, 0xc4, 0x03, 0x56, 0x44, 0x7f, 0xa9, \ 0x2a, 0xbb, 0xc1, 0x53, 0xdc, 0x0b, 0x9d, 0x6c, 0x31, 0x74, 0xf6, 0x46, 0xac, 0x89, 0x14, 0xe1, \ 0x16, 0x3a, 0x69, 0x09, 0x70, 0xb6, 0xd0, 0xed, 0xcc, 0x42, 0x98, 0xa4, 0x28, 0x5c, 0xf8, 0x86 C := 0x01, 0x01, 0x04, 0x01, 0x08, 0x05, 0x02, 0x09, \ 0x09, 0x01, 0x01, 0x04, 0x01, 0x08, 0x05, 0x02, \ 0x02, 0x09, 0x01, 0x01, 0x04, 0x01, 0x08, 0x05, \ 0x05, 0x02, 0x09, 0x01, 0x01, 0x04, 0x01, 0x08, \ 0x08, 0x05, 0x02, 0x09, 0x01, 0x01, 0x04, 0x01, \ 0x01, 0x08, 0x05, 0x02, 0x09, 0x01, 0x01, 0x04, \ 0x04, 0x01, 0x08, 0x05, 0x02, 0x09, 0x01, 0x01, \ 0x01, 0x04, 0x01, 0x08, 0x05, 0x02, 0x09, 0x01 # Matriz construida a partir del vector de inicialización IM := 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0 R := 10 función obtenerMatrizRedondeadaConstante(r) cr := IM para j de 0 a 7 cr[j] := S[8 * (r - 1) + j] fin para devolver cr fin de la función func whirlpoolRound(matriz, clave) # Aplicar la transformación no lineal γ para i de 0 a 7 para j de 0 a 7 matriz[i * 8 + j] = S[matriz[i * 8 + j]] fin para fin para # Aplicar permutación cíclica π tmp := matriz para i de 0 a 7 para j de 0 a 7 # '+ 8' para evitar índices negativos matriz[i * 8 + j] = tmp[((i - j + 8) % 8) * 8 + j] fin para fin para matriz := tmp # Aplicar difusión lineal θ matriz := producto escalar(matriz, C) # Aplicar suma de clave σ[clave] matriz := matriz xor clave matriz de retorno fin de la función función remolino(M) m, t := pad(M) # Devuelve (mensajerellenadodivididoenfragmentos, cantidaddefragmentos) H := IM para i desde 0 hasta t W := m[t] Kr := H W := W xor H para r de 1 a R cr := getConstantRoundMatrix(r) Kr := whirlpoolRound(Kr, cr) W := remolinoRedondeado(W, Kr) fin para H := H xor W H := H xor m[t] fin para devolver matrixToHexString(H) fin de la función

Para la difusión lineal${\displaystyle \theta }$Se requiere una multiplicación de matrices . La aritmética de campos de Galois se puede utilizar para escribir este algoritmo de multiplicación :

función producto escalar(A, B) tmp: Matriz para i de 0 a 7 para j de 0 a 7 tmp[i * 8 + j] := 0 para k de 0 a 7 # Multiplicación del campo de Galois (2^8) a := A[i * 8 + k]; b := B[k * 8 + j]; producto := 0; mientras b > 0 si b y 1 == 1 producto := producto xor a fin si si a & 0x80 != 0 a := (a << 1) xor 0x11d # x^8 + x^4 + x^3 + x^2 + 1 demás a := a << 1 fin si b := b >> 1 fin mientras tmp[i * 8 + j] := tmp[i * 8 + j] producto xor fin para fin para fin para devolver tmp fin de la función

Aquí se muestra una implementación del relleno de 512 bits (tamaño de 64 bits, big-endian ) :

panel de función(M) longitud_original := len(M) # En bytes # 512 bits (longitud total) - 256 bits (longitud del tamaño) - 1 bit (bit de relleno) # 64 bytes - 32 bytes - 1 byte = 31 bytes relleno := (31 - longitud_original) % 64 relleno := (relleno + 64) % 64 # Evitar relleno negativo longitud_total := longitud_original + 1 + relleno + 32 # En bytes relleno: Byte[longitud_total] # Copiar mensaje original para i desde 0 hasta longitud_original - 1 relleno[i] := M[i] fin para relleno[longitud_original] := 0x80 # Añadir el bit '1', luego 7 bits '0' para i desde original_length + 1 hasta original_length + relleno relleno[i] := 0x00 # Añadir 8 bits '0' fin para para i de 0 a 31 relleno[longitud_total - 32 + i] := (longitud_original * 8) >> (8 * (31 - i)) & 0xff fin para cantidad_de_trozos := longitud_total / 64 dividido := Byte[cantidad_de_fragmento][64] para i desde 0 hasta chunk_amount - 1 para j de 0 a 63 dividido[i][j] := relleno[i * 64 + j] fin para fin para devolver dividido, cantidad_de_trozo fin de la función

Y aquí tenéis un ejemplo de conversión de matriz a cadena de caracteres :

función matrixToHexString(matriz) HEX := "0123456789abcdef" resultado: Byte[128] para i de 0 a 63 byte := matriz[i] resultado[i * 2] := HEX[byte >> 4] resultado[i * 2 + 1] := HEX[byte & 0xf] fin para devolver resultado fin de la función