HAVAL

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 11 de mayo de 2018; las comprobaciones requieren 6 ediciones .

HAVAL
Desarrolladores	Yuliang Zheng , Josef Pieprzyk , Jennifer Seberry
Creado	1992
publicado	1992
tamaño de hash	128, 160, 192, 224, 256 bits
Número de rondas	96, 128, 160
Tipo de	función hash

HAVAL es una función hash criptográfica desarrollada por Yuliang Zheng , Josef Pieprzyk y Jennifer Seberry en 1992 .

Dado un mensaje de entrada arbitrario, la función genera un valor hash denominado resumen del mensaje , que puede tener una longitud de 128, 160, 192, 224 o 256 bits. El número de iteraciones es variable, de 3 a 5. El número de rondas en cada iteración es 32. Es una modificación de MD5 .

Algoritmo

Definamos funciones booleanas que se utilizan para realizar operaciones bit a bit en palabras.
1.ª iteración 2.ª iteración 3.ª iteración 4.ª iteración 5.ª iteración El algoritmo recibe un flujo de datos de entrada, cuyo hash debe encontrarse. Este flujo se divide en bloques, cada uno de 1024 bits de longitud. Los siguientes son los 3 pasos del algoritmo. $F_{1}(x_{6},x_{5},x_{4},x_{3},x_{2},x_{1},x_{0})=x_{1}x_{ 4}\oplus x_{2}x_{5}\oplus x_{3}x_{6}\oplus x_{0}x_{1}\oplus x_{0}$
$F_{2}(x_{6},x_{5},x_{4},x_{3},x_{2},x_{1},x_{0})=x_{1}x_{ 2}x_{3}\oplus x_{2}x_{4}x_{5}\oplus x_{1}x_{2}\oplus x_{1}x_{4}\oplus x_{2}x_{6} \oplus x_{3}x_{5}\oplus x_{4}x_{5}\oplus x_{0}x_{2}\oplus x_{0}$
$F_{3}(x_{6},x_{5},x_{4},x_{3},x_{2},x_{1},x_{0})=x_{1}x_{ 2}x_{3}\oplus x_{1}x_{4}\oplus x_{2}x_{5}\oplus x_{3}x_{6}\oplus x_{0}x_{3}\oplus x_{ 0}$
$F_{4}(x_{6},x_{5},x_{4},x_{3},x_{2},x_{1},x_{0})=x_{1}x_{ 2}x_{3}\oplus x_{2}x_{4}x_{5}\oplus x_{3}x_{4}x_{6}\oplus x_{1}x_{4}\oplus x_{2} x_{6}\oplus x_{3}x_{4}\oplus x_{3}x_{5}\oplus x_{3}x_{6}\oplus x_{4}x_{5}\oplus x_{4} x_{6}\oplus x_{0}x_{4}\oplus x_{0}$
$F_{5}(x_{6},x_{5},x_{4},x_{3},x_{2},x_{1},x_{0})=x_{1}x_{ 4}\oplus x_{2}x_{5}\oplus x_{3}x_{6}\oplus x_{0}x_{1}x_{2}x_{3}\oplus x_{0}x_{5} \oplus x_{0}$

Paso 1. Expandiendo el mensaje

Primero, el mensaje se expande para que su longitud en bits sea igual a 944 módulo 1024. Para hacer esto, se escribe un bit al final del mensaje y luego el número requerido de bits cero. Los 80 bits restantes se agregan con una representación de 64 bits del número de bits del mensaje antes de la alineación (campo MSGLENG), una representación de 10 bits de la longitud del resumen del mensaje (campo DGSTLENG), una representación de 3 bits del número de iteraciones (campo PASS), y una representación de 3 bits de la versión HAVAL (campo VERSION).

Paso 2. Procesamiento del mensaje en bloques de 1024 bits

Escribamos un mensaje extendido en la forma: , donde es un bloque de 1024 bits y n es el número de bloques en un mensaje extendido. A continuación, para i de 0 a n-1, realizamos el siguiente cálculo: , donde H es la función de compresión que se describe a continuación y es una constante de 256 bits. $B_{n-1}B_{n-2}\ldots B_{0}$ ${\ Displaystyle B_ {yo}}$

$D_{i+1}=H(D_{i},B_{i})$ $D_0$

Función de compresión H

H procesa el bloque de mensajes en 3, 4 o 5 iteraciones (según el valor del campo PASS). Denotemos las funciones de compresión utilizadas en las iteraciones por y . Sea una constante de 256 bits y sea la salida de 256 bits de la función H . Entonces H se puede describir de la siguiente manera (ver figura): ${\ estilo de visualización H_{1},H_{2},H_{3},H_{4))$ ${\ estilo de visualización H_ {5}}$ $D_{en}$ $D_{fuera}$

$E_{0}=D_{en};$
${\ estilo de visualización E_ {1} = H_ {1} (E_ {0}, B);}$
$E_{2}=H_{2}(E_{1},B);$
$E_{3}=H_{3}(E_{2},B);$
$E_{4}=H_{4}(E_{3},B);\qquad {\mbox{si PASA=4, 5))$
$E_{5}=H_{5}(E_{4},B);\qquad {\mbox{si PASA=5))$
$D_{out}={\begin{cases}E_{3}\boxplus E_{0},&{\mbox{if PASS=3}}\\E_{4}\boxplus E_{0},& {\mbox{si APROBÓ=4}}\\E_{5}\boxplus E_{0},&{\mbox{si APROBÓ=5}}\end{casos}}$
(Nota: una operación de tipo es una operación de la forma: , donde palabras de 32 bits. $D_{salida}=E_{x}\boxplus E_{y};$ $D_{salida,n-1}=E_{x,n-1}\boxplus E_{y,n-1};D_{salida,n-2}=E_{x,n-2}\boxplus E_{y,n-2};\dots D_{out,0}=E_{x,0}\boxplus E_{y,0};$ $D_{fuera,i},E_{x,i},E_{y,i},0\leqslant i\leqslant n-1$

Denotemos el número de iteración por j (j =1,…,5). El número de iteración j corresponde a la función de compresión . La entrada de cada función es y , donde es un bloque de mensaje de 1024 bits que consta de 32 palabras , a consta de 8 palabras . Entonces se puede escribir de la siguiente manera: ${\ Displaystyle H_ {j}}$ ${\ Displaystyle H_ {j}}$ $B$ $E_{j-1}$ $B$ ${\displaystyle W_{31}W_{30}\puntos W_{0))$ $E_{j-1}$ ${\displaystyle E_{j-1.7}E_{j-1.6}\dots E_{j-1.0))$ ${\ Displaystyle H_ {j}}$

1 . Dejar

T_{0,i}=E_{j-1,i},0\leqslant i\leqslant 7

2 . Repita los siguientes pasos para i de 0 a 31:

P={\begin{casos}F_{j}\circ \phi _{3,j}(T_{i,6},T_{i,5},T_{i,4},T_{i ,3},T_{i,2},T_{i,1},T_{i,0}),&{\mbox{si PASA=3}}\\F_{j}\circ \phi _{4 ,j}(T_{i,6},T_{i,5},T_{i,4},T_{i,3},T_{i,2},T_{i,1},T_{i, 0}),&{\mbox{si PASA=4}}\\F_{j}\circ \phi _{5,j}(T_{i,6},T_{i,5},T_{i, 4},T_{i,3},T_{i,2},T_{i,1},T_{i,0}),&{\mbox{si PASA=5}}\end{casos}}

{\displaystyle R=(P\ggg 7)\boxplus (T_{i,7}\ggg 11)\boxplus W_{ord_{j}(i)}\boxplus K_{j,i))

, donde son constantes de 32 bits

{\ Displaystyle K_ {j, yo}}

T_{i+1,7}=T_{i,6};\ T_{i+1,6}=T_{i,5};\ T_{i+1,5}=T_{i, 4};\ T_{i+1,4}=T_{i,3};

T_{i+1,3}=T_{i,2};\ T_{i+1,2}=T_{i,1};\ T_{i+1,1}=T_{i, 0};\ T_{i+1,0}=R.

3 . Sea y sea una salida de 256 bits .

E_{j,i}=T_{32,i},0\leqslant i\leqslant 7

E_{j}=E_{j,7}E_{j,6}\puntos E_{j,0}

{\ Displaystyle H_ {j}}

Notación: - composición de dos funciones (la primera se ejecuta ), ${\ estilo de visualización f \ círculo g}$ $gramo$

\caja más

- módulo de adición ,

2^{32}

{\ estilo de visualización \ phi _ {3, j}, \ phi _ {4, j}, \ phi _ {5, j}}

son las permutaciones descritas en la Tabla 2.

Nota: no se utilizan constantes en la primera iteración (es decir, ). $K_{j,i}=0.0\leqslant i\leqslant 31$

A diferencia de la iteración 1, en la iteración 2 y posteriores , no se procesa en el orden de las palabras, sino en el orden especificado en la Tabla 1. $B$

Tabla 1. Orden de procesamiento de textos

${\displaystyle ord_{1))$ ( ) $H_1$	0	una	2	3	cuatro	5	6	7	ocho	9	diez	once	12	13	catorce	quince	dieciséis	17	Dieciocho	19	veinte	21	22	23	24	25	26	27	28	29	treinta	31
${\displaystyle ord_{2))$ ( ) $H_2$	5	catorce	26	Dieciocho	once	28	7	dieciséis	0	23	veinte	22	una	diez	cuatro	ocho	treinta	3	21	9	17	24	29	6	19	12	quince	13	2	25	31	27
${\displaystyle ord_{3))$ ( ) $H_3$	19	9	cuatro	veinte	28	17	ocho	22	29	catorce	25	12	24	treinta	dieciséis	26	31	quince	7	3	una	0	Dieciocho	27	13	6	21	diez	23	once	5	2
${\displaystyle ord_{4))$ ( ) $H_4$	24	cuatro	0	catorce	2	7	28	23	26	6	treinta	veinte	Dieciocho	25	19	3	22	once	31	21	ocho	27	12	9	una	29	5	quince	17	diez	dieciséis	13
$orden_{5}$ ( ) ${\ estilo de visualización H_ {5}}$	27	3	21	26	17	once	veinte	29	19	0	12	7	13	ocho	31	diez	5	9	catorce	treinta	Dieciocho	6	28	24	2	23	dieciséis	22	cuatro	una	25	quince

Tabla 2. Permutaciones

	${\ estilo de visualización x_ {6))$ $\flecha hacia abajo$	$x_{5}$ $\flecha hacia abajo$	$x_{4}$ $\flecha hacia abajo$	$x_{3}$ $\flecha hacia abajo$	$x_{2}$ $\flecha hacia abajo$	$x_{1}$ $\flecha hacia abajo$	$x_{0}$ $\flecha hacia abajo$
${\ estilo de visualización \ phi _ {3,1}}$	$x_{1}$	$x_{0}$	$x_{3}$	$x_{5}$	${\ estilo de visualización x_ {6))$	$x_{2}$	$x_{4}$
${\ estilo de visualización \ phi _ {3,2}}$	$x_{4}$	$x_{2}$	$x_{1}$	$x_{0}$	$x_{5}$	$x_{3}$	${\ estilo de visualización x_ {6))$
${\ estilo de visualización \ phi _ {3,3}}$	${\ estilo de visualización x_ {6))$	$x_{1}$	$x_{2}$	$x_{3}$	$x_{4}$	$x_{5}$	$x_{0}$
${\ estilo de visualización \ phi _ {4,1}}$	$x_{2}$	${\ estilo de visualización x_ {6))$	$x_{1}$	$x_{4}$	$x_{5}$	$x_{3}$	$x_{0}$
${\ estilo de visualización \ phi _ {4,2}}$	$x_{3}$	$x_{5}$	$x_{2}$	$x_{0}$	$x_{1}$	${\ estilo de visualización x_ {6))$	$x_{4}$
${\ estilo de visualización \ phi _ {4,3}}$	$x_{1}$	$x_{4}$	$x_{3}$	${\ estilo de visualización x_ {6))$	$x_{0}$	$x_{2}$	$x_{5}$
${\ estilo de visualización \ phi _ {4,4}}$	${\ estilo de visualización x_ {6))$	$x_{4}$	$x_{0}$	$x_{5}$	$x_{2}$	$x_{1}$	$x_{3}$
${\ estilo de visualización \ phi _ {5,1}}$	$x_{3}$	$x_{4}$	$x_{1}$	$x_{0}$	$x_{5}$	$x_{2}$	${\ estilo de visualización x_ {6))$
${\ estilo de visualización \ phi _ {5,2}}$	${\ estilo de visualización x_ {6))$	$x_{2}$	$x_{1}$	$x_{0}$	$x_{3}$	$x_{4}$	$x_{5}$
${\ estilo de visualización \ phi _ {5,3}}$	$x_{2}$	${\ estilo de visualización x_ {6))$	$x_{0}$	$x_{4}$	$x_{3}$	$x_{1}$	$x_{5}$
${\ estilo de visualización \ phi _ {5,4}}$	$x_{1}$	$x_{5}$	$x_{3}$	$x_{2}$	$x_{0}$	$x_{4}$	${\ estilo de visualización x_ {6))$
${\ estilo de visualización \ phi _ {5,5}}$	$x_{2}$	$x_{5}$	$x_{0}$	${\ estilo de visualización x_ {6))$	$x_{4}$	$x_{3}$	$x_{1}$

Paso 3. Formación del resumen del mensaje

Este paso usa la longitud de 256 bits obtenida en el paso 2. Si el tamaño de hash requerido es de 256 bits, entonces hay un resumen de mensaje. Consideremos los otros 4 casos. $D_{n}=D_{n,7}D_{n,6}\puntos D_{n,0}$ $D_{n}$

1. Tamaño de hash: 128 bits

Pongámoslo de la siguiente forma: ${\ estilo de visualización D_{n,7},D_{n,6},D_{n,5))$ $D_{n,4}$

D_{n,7}=X_{7,3}^{[8]}X_{7,2}^{[8]}X_{7,1}^{[8]}X_{7, 0}^{[8]}

D_{n,6}=X_{6,3}^{[8]}X_{6,2}^{[8]}X_{6,1}^{[8]}X_{6, 0}^{[8]}

D_{n,5}=X_{5,3}^{[8]}X_{5,2}^{[8]}X_{5,1}^{[8]}X_{5, 0}^{[8]}

D_{n,4}=X_{4,3}^{[8]}X_{4,2}^{[8]}X_{4,1}^{[8]}X_{4, 0}^{[8]}

(el superíndice indica la longitud de X en bits)

Luego, el resumen del mensaje es de 128 bits , donde ${\displaystyle Y_{3}Y_{2}Y_{1}Y_{0))$

Y_{3}=D_{n,3}\boxplus (X_{7,3}^{[8]}X_{6,2}^{[8]}X_{5,1}^{[ 8]}X_{4,0}^{[8]})

Y_{2}=D_{n,2}\boxplus (X_{7,2}^{[8]}X_{6,1}^{[8]}X_{5,0}^{[ 8]}X_{4,3}^{[8]})

Y_{1}=D_{n,1}\boxplus (X_{7,1}^{[8]}X_{6,0}^{[8]}X_{5,3}^{[ 8]}X_{4,2}^{[8]})

Y_{0}=D_{n,0}\boxplus (X_{7,0}^{[8]}X_{6,3}^{[8]}X_{5,2}^{[ 8]}X_{4,1}^{[8]})

2. Tamaño de hash: 160 bits

Pongámoslo de la siguiente forma: ${\ estilo de visualización D_ {n, 7}, D_ {n, 6}}$ $D_{n,5}$

D_{n,7}=X_{7,4}^{[7]}X_{7,3}^{[6]}X_{7,2}^{[7]}X_{7, 1}^{[6]}X_{7,0}^{[6]}

D_{n,6}=X_{6,4}^{[7]}X_{6,3}^{[6]}X_{6,2}^{[7]}X_{6, 1}^{[6]}X_{6,0}^{[6]}

D_{n,5}=X_{5,4}^{[7]}X_{5,3}^{[6]}X_{5,2}^{[7]}X_{5, 1}^{[6]}X_{5,0}^{[6]}

Luego, el resumen del mensaje es de 160 bits , donde ${\displaystyle Y_{4}Y_{3}Y_{2}Y_{1}Y_{0))$

Y_{4}=D_{n,4}\boxplus (X_{7,4}^{[7]}X_{6,3}^{[6]}X_{5,2}^{[ 7]})

Y_{3}=D_{n,3}\boxplus (X_{7,3}^{[6]}X_{6,2}^{[7]}X_{5,1}^{[ 6]})

Y_{2}=D_{n,2}\boxplus (X_{7,2}^{[7]}X_{6,1}^{[6]}X_{5,0}^{[ 6]})

Y_{1}=D_{n,1}\boxplus (X_{7,1}^{[6]}X_{6,0}^{[6]}X_{5,4}^{[ 7]})

Y_{0}=D_{n,0}\boxplus (X_{7,0}^{[6]}X_{6,4}^{[7]}X_{5,3}^{[ 6]})

3. Tamaño de hash: 192 bits

Pongámoslo de la siguiente forma: ${\ Displaystyle D_ {n, 7}}$ $D_{n,6}$

D_{n,7}=X_{7,5}^{[6]}X_{7,4}^{[5]}X_{7,3}^{[5]}X_{7, 2}^{[6]}X_{7,1}^{[5]}X_{7,0}^{[5]}

D_{n,6}=X_{6,5}^{[6]}X_{6,4}^{[5]}X_{6,3}^{[5]}X_{6, 2}^{[6]}X_{6,1}^{[5]}X_{6,0}^{[5]}

Dejar

Y_{5}=D_{n,5}\boxplus (X_{7,5}^{[6]}X_{6,4}^{[5]})

Y_{4}=D_{n,4}\boxplus (X_{7,4}^{[5]}X_{6,3}^{[5]})

Y_{3}=D_{n,3}\boxplus (X_{7,3}^{[5]}X_{6,2}^{[6]})

Y_{2}=D_{n,2}\boxplus (X_{7,2}^{[6]}X_{6,1}^{[5]})

Y_{1}=D_{n,1}\boxplus (X_{7,1}^{[5]}X_{6,0}^{[5]})

Y_{0}=D_{n,0}\boxplus (X_{7,0}^{[5]}X_{6,5}^{[6]})

${\displaystyle Y_{5}Y_{4}Y_{3}Y_{2}Y_{1}Y_{0))$ - resumen del mensaje.

4. Tamaño de hash - 224 bits

Vamos a presentarlo de la siguiente forma: ${\ Displaystyle D_ {n, 7}}$

D_{n,7}=X_{7,6}^{[5]}X_{7,5}^{[5]}X_{7,4}^{[4]}X_{7, 3}^{[5]}X_{7,2}^{[4]}X_{7,1}^{[5]}X_{7,0}^{[4]}

Luego, el resumen del mensaje es de 224 bits , donde ${\displaystyle Y_{6}Y_{5}Y_{4}Y_{3}Y_{2}Y_{1}Y_{0))$

Y_{6}=D_{n,6}\boxplus (X_{7,0}^{[4]})

Y_{5}=D_{n,5}\boxplus (X_{7,1}^{[5]})

Y_{4}=D_{n,4}\boxplus (X_{7,2}^{[4]})

Y_{3}=D_{n,3}\boxplus (X_{7,3}^{[5]})

Y_{2}=D_{n,2}\boxplus (X_{7,4}^{[4]})

Y_{1}=D_{n,1}\boxplus (X_{7,5}^{[5]})

Y_{0}=D_{n,0}\boxplus (X_{7,6}^{[5]})

Constantes utilizadas en el algoritmo

Este algoritmo utiliza 136 constantes de 32 bits. Vamos a escribirlos en el siguiente orden:

una.

{\displaystyle D_{0,0},D_{0,1},\puntos,D_{0,7))

{\displaystyle K_{2,0},K_{2,1},\puntos,K_{2,31))

{\displaystyle K_{3,0},K_{3,1},\puntos,K_{3,31))

cuatro

{\displaystyle K_{4,0},K_{4,1},\puntos,K_{4,31))

K_{5,0},K_{5,1},\puntos,K_{5,31}

243F6A88 85A308D3 13198A2E 03707344 A4093822 299F31D0 082EFA98 EC4E6C89

452821E6 38D01377 BE5466CF 34E90C6C C0AC29B7 C97C50DD 3F84D5B5 B5470917 9216D5D9 8979FB1B
D1310BA6 98DFB5AC 2FFD72DB D01ADFB7 B8E1AFED 6A267E96 BA7C9045 F12C7F99 24A19947
B3916CF7 0801F2E2 858EFC16 636920D8 71574E69 A458FEA3
F4933D7E 0D95748F 728EB658 718BCD58 82154AEE 7B54A41D C25A59B5

9C30D539 2AF26013 C5D1B023 286085F0 CA417918 B8DB38EF 8E79DCB0 603A180E 6C9E0E8B B01E8A3E
D71577C1 BD314B27 78AF2FDA 55605C60 E65525F3 AA55AB94 57489862 63E81440 55CA396A
2AAB10B6 B4CC5C34 1141E8CE A15486AF 7C72E993 B3EE1411
636FBC2A 2BA9C55D 741831F6 CE5C3E16 9B87931E AFD6BA33 6C24CF5C

7A325381 28958677 3B8F4898 6B4BB9AF C4BFE81B 66282193 61D809CC FB21A991 487CAC60 5DEC8032
EF845D5D E98575B1 DC262302 EB651B88 23893E81 D396ACC5 0F6D6FF3 83F44239 2E0B4482
A4842004 69C8F04A 9E1F9B5E 21C66842 F6E96C9A 670C9C61
ABD388F0 6A51A0D2 D8542F68 960FA728 AB5133A3 6EEF0B6C 137A3BE4

BA3BF050 7EFB2A98 A1F1651D 39AF0176 66CA593E 82430E88 8CEE8619 456F9FB4 7D84A5C3 3B8B5EBE
E06F75D8 85C12073 401A449F 56C16AA6 4ED3AA62 363F7706 1BFEDF72 429B023D 37D0D724
D00A1248 DB0FEAD3 49F1C09B 075372C9 80991B7B 25D479D8
F6E8DEF7 E3FE501A B6794C3B 976CE0BD 04C006BA C1A94FB6 409F60C4

Las primeras 8 constantes representan los primeros 256 bits de la parte fraccionaria del número . Las constantes corresponden a los siguientes 1024 bits de la parte fraccionaria , y así sucesivamente. ${\displaystyle D_{0,0},D_{0,1},\puntos,D_{0,7))$ $\Pi$ ${\displaystyle K_{2,0},K_{2,1},\puntos,K_{2,31))$ $\Pi$

Funciones , , y $F_{1}$ $F_{2}$ $F_{3}$ $F_{4}$ $F_{5}$ _

Las funciones booleanas , , y , utilizadas en el algoritmo, tienen una serie de propiedades útiles en el caso de la permutación preliminar de sus argumentos: $F_{1}$ $F_{2}$ $F_{3}$ $F_{4}$ $F_{5}$

1) Están equilibrados por 0 y 1. Esto significa que la salida de la función para un conjunto arbitrario de datos de entrada con la misma probabilidad (1/2) puede ser 0 o 1. 2) Son altamente no lineales. [una] 3) Cumplen el criterio estricto de avalancha , es decir, cuando cambia el valor de cualquiera de las variables de entrada, el valor de la función cambia con una probabilidad de 1/2. 4) No se pueden obtener unos de otros aplicando transformaciones lineales a las variables de entrada. 5) Este conjunto de funciones no está correlacionado entre sí en la salida, es decir, cualquier par de funciones no está correlacionada entre sí en la salida (funciones y no se correlacionan mutuamente en la salida si , y están balanceadas por 0 y 1, no lineales funciones)

F

gramo

F

gramo

{\ estilo de visualización f \ o más g}

HAVAL - hashes

Los hashes HAVAL generalmente se representan como una secuencia de 32, 40, 48, 56 o 64 números hexadecimales.
Algunos ejemplos de hash (tamaño - 256 bits, número de iteraciones - 5):

HAVAL(" El veloz zorro pardo salta sobre el perro perezoso ") = b89c551cdfe2e06dbd4cea2be1bc7d557416c58ebb4d07cbc94e49f710c55be4

Incluso un pequeño cambio en el mensaje de entrada (en nuestro caso, por un carácter: el carácter "d" se reemplaza por el carácter "c") conduce a un cambio completo en el hash.

HAVAL("El veloz zorro marrón salta sobre el engranaje perezoso") = 60983bb8c8f49ad3bea29899b78cd741f4c96e911bbc272e5550a4f195a4077e

Un ejemplo de un hash HAVAL para una cadena "nula":

HAVAL("") = be417bb4dd5cfb76c7126f4f8eeb1553a449039307b1a3cd451dbfdc0fbbe330

Comparación entre HAVAL y MD5

A diferencia de la función hash MD5, que tiene un tamaño fijo del resumen y el número de iteraciones, HAVAL proporciona 15 variantes de algoritmo diferentes al combinar la longitud del resumen y el número de iteraciones. Esto proporciona más flexibilidad y, por lo tanto, hace que la función hash sea más adecuada para aplicaciones que requieren diferentes longitudes de hash de mensajes y diferentes niveles de seguridad.
Los experimentos han demostrado que HAVAL es un 60 % más rápido que MD5 en 3 iteraciones, un 15 % más rápido en 4 iteraciones e igual de rápido en cinco iteraciones.

Criptoanálisis

Colisiones HAVAL

Una colisión hash obtiene el mismo valor de función para diferentes mensajes.

En 2003, Bart Van Rompay, Alex Biryukov , Bart Prenel y Joos Vandewalle descubrieron una colisión para HAVAL de 3 iteraciones. [2] Encontrar esta colisión requirió aproximadamente ejecuciones de la función de contracción H . $2^{29}$

En 2004, los investigadores chinos Wang Xiaoyun , Feng Dengguo , Lai Xuejia y Yu Hongbo anunciaron una vulnerabilidad que habían descubierto en el HAVAL-128 de 3 iteraciones que permite encontrar colisiones mediante cálculos HAVAL. [3] $2^7$

En 2006, un grupo de científicos chinos liderados por Wang Xiaoyun y Yu Hongbo llevaron a cabo dos ataques contra HAVAL de 4 iteraciones, que también requirieron operaciones de hashing, respectivamente. También propusieron el primer ataque teórico en HAVAL de 5 iteraciones con el número de operaciones hash aproximadamente igual a . [cuatro] $2^{43}$ $2^{{36}}$ ${\ estilo de visualización 2^{123}}$

Véase también

MD5
SHA-1

Notas

↑ Tokareva N. N. Funciones booleanas fuertemente no lineales: funciones dobladas y sus generalizaciones (enlace inaccesible) (2008). Archivado desde el original el 15 de febrero de 2012. (Ruso)
↑ Bart Van Rompay, Alex Biryukov, Bart Preneel y Joos Vandewalle. Criptoanálisis de HAVAL de 3 pasos . (enlace no disponible)
↑ Xiaoyun Wang, Dengguo Feng, Xuejia Lai, Hongbo Yu. Colisiones para funciones hash MD4, MD5, HAVAL-128 y RIPEMD (inglés) (enlace descendente) (17 de agosto de 2004). Archivado desde el original el 23 de agosto de 2011.
↑ Xiaoyun Wang, Aaram Yun, Parque Sangwoo, Hongbo Yu. Criptoanálisis del HAVAL completo con 4 y 5 pases (inglés) (2006). (enlace no disponible)

Enlaces

https://web.archive.org/web/20080905132936/http://labs.calyptix.com/files/haval-paper.pdf – Yuliang Zheng, Josef Pieprzyk y Jennifer Seberry: “HAVAL es un algoritmo de hashing unidireccional con longitud de salida variable", Advances in Cryptology - AUSCRYPT'92, Lecture Notes in Computer Science, Vol.718, pp. 83-104, Springer-Verlag, 1993.
https://www.researchgate.net/publication/225789941_HAVAL_-_A_one-way_hashing_algorithm_with_variable_length_of_output_extended_abstract (contiene un orden constante fijo)
Cálculo en línea de hashes HAVAL

Funciones hash
propósito general	Adler-32 CDN Suma de comprobación de Fletcher FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH - Árbol de hachís picadillo de jenkins suma de hash
Criptográfico	Stribog GOST R 34.11-94 Cinturón BLAKE BMW CubeHash ECO edonkey2k FSB Fuga Grostl HAVAL Hamsi J H Kupyna Hachís de LM luffa MD2 MD4 MD5 MD6 N-hachís RIPEMD-128 RIPEMD-160 RIPEMD-256 RIPEMD-320 SHA-1 SHA-2 Keccak (SHA-3) SHABAL SHAvite-3 SIMD RÁPIDO Piel Snefru Tigre Torbellino
Funciones de generación de claves	cripta PBKDF2 cripta Argón2 Lyra2
Número de cheque ( comparación )	Suma de verificación Algoritmo de Verhouff Algoritmo lunar Maldito algoritmo Código de barras cuentas bancarias tarjetas bancarias ES EN SNILES OKPO ESTAÑO OKATO ISBN OGRN y OGRNIP VIN
Hachís	Comparación de números de cheque Protocolos de autenticación Comparación de códigos de barras Criptografía Enlace magnético firma Merkle ed2k URNA