HAVAL

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 11 maj 2018; kontroller kräver 6 redigeringar .

HAVAL
Utvecklare	Yuliang Zheng , Josef Pieprzyk , Jennifer Seberry
Skapad	1992
publiceras	1992
Hash storlek	128, 160, 192, 224, 256 bitar
Antal omgångar	96, 128, 160
Sorts	hash-funktion

HAVAL är en kryptografisk hashfunktion utvecklad av Yuliang Zheng , Josef Pieprzyk och Jennifer Seberry 1992 .

Givet ett godtyckligt ingångsmeddelande genererar funktionen ett hashvärde som kallas meddelandesammandraget , som kan vara 128, 160, 192, 224 eller 256 bitar långt. Antalet iterationer är variabelt, från 3 till 5. Antalet omgångar vid varje iteration är 32. Det är en modifiering av MD5 .

Algoritm

Låt oss definiera booleska funktioner som används för att utföra bitvisa operationer på ord.
1:a iterationen 2: a iterationen 3: e iterationen 4:e iterationen 5 :e iterationen Algoritmen tar emot en indataström, vars hash måste hittas. Denna ström är uppdelad i block, vart och ett 1024 bitar långt. Följande är de 3 stegen i algoritmen. $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}$

Steg 1. Expandera meddelandet

Först utökas meddelandet så att dess längd i bitar blir lika med 944 modulo 1024. För att göra detta skrivs en enbit till slutet av meddelandet och sedan det erforderliga antalet nollbitar. De återstående 80 bitarna läggs till med en 64-bitars representation av antalet bitar i meddelandet före justering (MSGLENG-fält), en 10-bitars representation av meddelandesammandragens längd (DGSTLENG-fält), en 3-bitars representation av antalet av iterationer (PASS-fält) och en 3-bitars representation av HAVAL-versionen ( VERSION-fält).

Steg 2. Bearbeta meddelandet i block om 1024 bitar

Låt oss skriva ett utökat meddelande i formen: , där är ett 1024-bitars block och n är antalet block i ett utökat meddelande. Därefter, för i från 0 till n-1, utför vi följande beräkning: , där H är komprimeringsfunktionen som beskrivs nedan och är en 256-bitars konstant. ${\displaystyle B_{n-1}B_{n-2}\ldots B_{0))$ ${\displaystyle B_{i))$

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

H komprimeringsfunktion

H behandlar meddelandeblocket i 3, 4 eller 5 iterationer (beroende på värdet på PASS-fältet). Låt oss beteckna komprimeringsfunktionerna som används i iterationer med och . Låt vara någon 256-bitars konstant, och låt vara 256-bitars utdata från funktionen H . Då kan H beskrivas så här (se figur): ${\displaystyle H_{1},H_{2},H_{3},H_{4))$ $H_{5}$ $D_{in}$ $D_{out}$

$E_{0}=D_{in};$
$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{om PASS=4, 5))$
$E_{5}=H_{5}(E_{4},B);\qquad {\mbox{if PASS=5))$
$D_{out}={\begin{cases}E_{3}\boxplus E_{0},&{\mbox{if PASS=3}}\\E_{4}\boxplus E_{0},& {\mbox{if PASS=4}}\\E_{5}\boxplus E_{0},&{\mbox{if PASS=5}}\end{cases}}$
(Obs: en typoperation är en operation av formen: , där 32-bitars ord. $D_{out}=E_{x}\boxplus E_{y};$ $D_{ut,n-1}=E_{x,n-1}\boxplus E_{y,n-1};D_{out,n-2}=E_{x,n-2}\boxplus E_{y,n-2};\dots D_{out,0}=E_{x,0}\boxplus E_{y,0};$ $D_{out,i},E_{x,i},E_{y,i},0\leqslant i\leqslant n-1$

Låt oss beteckna iterationsnumret med j (j =1,…,5). Iterationsnummer j motsvarar komprimeringsfunktionen . Ingången för varje funktion är och , där är ett 1024-bitars meddelandeblock som består av 32 ord , a består av 8 ord . Då kan det skrivas så här: ${\displaystyle H_{j))$ ${\displaystyle H_{j))$ $B$ $E_{j-1}$ $B$ ${\displaystyle W_{31}W_{30}\dots W_{0))$ $E_{j-1}$ ${\displaystyle E_{j-1.7}E_{j-1.6}\dots E_{j-1.0))$ ${\displaystyle H_{j))$

1 . Låta

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

2 . Upprepa följande steg för i från 0 till 31:

P={\begin{cases}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{if PASS=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{if PASS=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{if PASS=5}}\end{cases}}

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

, där är 32-bitars konstanter

{\displaystyle K_{j,i))

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 . Låt och vara en 256-bitars utgång .

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

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

{\displaystyle H_{j))

Notation: - sammansättning av två funktioner (den första exekveras ), $f\circ g$ $g$

\box plus

- addition modulo ,

2^{32}

{\displaystyle \phi _{3,j},\phi _{4,j},\phi _{5,j))

är de permutationer som beskrivs i tabell 2.

Obs: inga konstanter används i den första iterationen (dvs ). $K_{j,i}=0.0\leqslant i\leqslant 31$

Till skillnad från iteration 1, i den andra och efterföljande iterationerna behandlas den inte i ordföljd utan i den ordning som anges i Tabell 1. $B$

Tabell 1. Ordbehandlingsordning

$ord_{1}$ ( ) $H_1$	0	ett	2	3	fyra	5	6	7	åtta	9	tio	elva	12	13	fjorton	femton	16	17	arton	19	tjugo	21	22	23	24	25	26	27	28	29	trettio	31
$ord_{2}$ ( ) $H_2$	5	fjorton	26	arton	elva	28	7	16	0	23	tjugo	22	ett	tio	fyra	åtta	trettio	3	21	9	17	24	29	6	19	12	femton	13	2	25	31	27
$ord_{3}$ ( ) $H_3$	19	9	fyra	tjugo	28	17	åtta	22	29	fjorton	25	12	24	trettio	16	26	31	femton	7	3	ett	0	arton	27	13	6	21	tio	23	elva	5	2
$ord_{4}$ ( ) $H_4$	24	fyra	0	fjorton	2	7	28	23	26	6	trettio	tjugo	arton	25	19	3	22	elva	31	21	åtta	27	12	9	ett	29	5	femton	17	tio	16	13
$ord_{5}$ ( ) $H_{5}$	27	3	21	26	17	elva	tjugo	29	19	0	12	7	13	åtta	31	tio	5	9	fjorton	trettio	arton	6	28	24	2	23	16	22	fyra	ett	25	femton

Tabell 2. Permutationer

	${\displaystyle x_{6))$ $\nedåtpil$	$x_{5}$ $\nedåtpil$	$x_{4}$ $\nedåtpil$	$x_{3}$ $\nedåtpil$	$x_{2}$ $\nedåtpil$	$x_{1}$ $\nedåtpil$	$x_{0}$ $\nedåtpil$
$\phi _{3,1}$	$x_{1}$	$x_{0}$	$x_{3}$	$x_{5}$	${\displaystyle x_{6))$	$x_{2}$	$x_{4}$
$\phi _{3,2}$	$x_{4}$	$x_{2}$	$x_{1}$	$x_{0}$	$x_{5}$	$x_{3}$	${\displaystyle x_{6))$
$\phi _{3,3}$	${\displaystyle x_{6))$	$x_{1}$	$x_{2}$	$x_{3}$	$x_{4}$	$x_{5}$	$x_{0}$
$\phi _{4,1}$	$x_{2}$	${\displaystyle x_{6))$	$x_{1}$	$x_{4}$	$x_{5}$	$x_{3}$	$x_{0}$
$\phi _{4,2}$	$x_{3}$	$x_{5}$	$x_{2}$	$x_{0}$	$x_{1}$	${\displaystyle x_{6))$	$x_{4}$
$\phi _{4,3}$	$x_{1}$	$x_{4}$	$x_{3}$	${\displaystyle x_{6))$	$x_{0}$	$x_{2}$	$x_{5}$
$\phi _{4,4}$	${\displaystyle x_{6))$	$x_{4}$	$x_{0}$	$x_{5}$	$x_{2}$	$x_{1}$	$x_{3}$
$\phi _{5,1}$	$x_{3}$	$x_{4}$	$x_{1}$	$x_{0}$	$x_{5}$	$x_{2}$	${\displaystyle x_{6))$
$\phi _{5,2}$	${\displaystyle x_{6))$	$x_{2}$	$x_{1}$	$x_{0}$	$x_{3}$	$x_{4}$	$x_{5}$
$\phi _{5,3}$	$x_{2}$	${\displaystyle x_{6))$	$x_{0}$	$x_{4}$	$x_{3}$	$x_{1}$	$x_{5}$
$\phi _{5,4}$	$x_{1}$	$x_{5}$	$x_{3}$	$x_{2}$	$x_{0}$	$x_{4}$	${\displaystyle x_{6))$
$\phi _{5,5}$	$x_{2}$	$x_{5}$	$x_{0}$	${\displaystyle x_{6))$	$x_{4}$	$x_{3}$	$x_{1}$

Steg 3. Bildning av meddelandesammandraget

Det här steget använder längden på 256 bitar som erhölls i steg 2. Om den erforderliga hashstorleken är 256 bitar finns det ett meddelandesammandrag. Låt oss överväga de andra fyra fallen. $D_{n}=D_{n,7}D_{n,6}\dots D_{n,0}$ $D_{n}$

1. Hashstorlek - 128 bitar

Låt oss sätta det i följande form: ${\displaystyle 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]}

(upphöjningen anger längden på X i bitar)

Då är meddelandesammandraget 128-bitars , där ${\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. Hashstorlek - 160 bitar

Låt oss sätta det i följande form: $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]}

Då är meddelandesammandraget 160-bitars , där ${\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. Hashstorlek - 192 bitar

Låt oss sätta det i följande form: ${\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]}

Låta

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))$ - meddelandesammanfattning.

4. Hashstorlek - 224 bitar

Låt oss presentera det i följande form: ${\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]}

Då är meddelandesammandraget 224-bitars , där ${\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]})

Konstanter som används i algoritmen

Denna algoritm använder 136 32-bitars konstanter. Låt oss skriva ner dem i följande ordning:

ett.

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

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

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

fyra.

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

K_{5,0},K_{5,1},\dots ,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

De första 8 konstanterna representerar de första 256 bitarna av bråkdelen av talet . Konstanterna motsvarar de nästa 1024 bitarna av bråkdelen , och så vidare. ${\displaystyle D_{0,0},D_{0,1},\dots ,D_{0,7))$ $\pi$ ${\displaystyle K_{2,0},K_{2,1},\dots ,K_{2,31))$ $\pi$

Funktioner , , och $F_{1}$ $F_{2}$ $F_{3}$ $F_{4}$ $F_{5}$ _

Booleska funktioner , , , och , som används i algoritmen, har ett antal användbara egenskaper i fallet med preliminär permutation av deras argument: $F_{1}$ $F_{2}$ $F_{3}$ $F_{4}$ $F_{5}$

1) De är balanserade med 0 och 1. Detta betyder att utdata från funktionen för en godtycklig uppsättning indata med lika sannolikhet (1/2) kan vara antingen 0 eller 1. 2) De är mycket icke-linjära. [ett] 3) De uppfyller Strict Avalanche -kriteriet, dvs när värdet på någon av ingångsvariablerna ändras ändras värdet på funktionen med en sannolikhet på 1/2. 4) De kan inte erhållas från varandra genom att tillämpa linjära transformationer på indatavariablerna. 5) Denna uppsättning funktioner är ömsesidigt icke-korrelerade i utdata, det vill säga alla funktionspar är ömsesidigt icke-korrelerade i utdata (funktioner och korrelerar inte ömsesidigt i utdata om , och är balanserade med 0 och 1, icke-linjära funktioner)

f

g

f

g

f\oplus g

HAVAL - hash

HAVAL-hashar representeras vanligtvis som en sekvens av 32, 40, 48, 56 eller 64 hexadecimala tal.
Några hash-exempel (storlek - 256 bitar, antal iterationer - 5):

HAVAL(" Den snabba bruna räven hoppar över den lata hunden ") = b89c551cdfe2e06dbd4cea2be1bc7d557416c58ebb4d07cbc94e49f710c55be4

Även en liten förändring i inmatningsmeddelandet (i vårt fall med ett tecken: tecknet "d" ersätts med tecknet "c") leder till en fullständig förändring av hashen.

HAVAL("Den kvicka bruna räven hoppar över den lata kuggen") = 60983bb8c8f49ad3bea29899b78cd741f4c96e911bbc272e5550a4f195a4077e

Ett exempel på en HAVAL-hash för en "null"-sträng:

HAVAL("") = be417bb4dd5cfb76c7126f4f8eeb1553a449039307b1a3cd451dbfdc0fbbe330

Jämförelse mellan HAVAL och MD5

Till skillnad från hashfunktionen MD5, som har en fast storlek på sammandraget och antalet iterationer, tillhandahåller HAVAL 15 olika algoritmvarianter genom att kombinera sammandragslängden och antalet iterationer. Detta ger mer flexibilitet och gör därför hashfunktionen mer lämpad för applikationer som kräver olika meddelandehashlängder och olika säkerhetsnivåer.
Experiment har visat att HAVAL är 60 % snabbare än MD5 vid 3 iterationer, 15 % snabbare vid 4 iterationer och lika snabb vid fem iterationer.

Kryptanalys

Kollisioner HAVAL

En hashkollision får samma funktionsvärde för olika meddelanden.

2003 upptäckte Bart Van Rompay, Alex Biryukov , Bart Prenel och Joos Vandewalle en kollision för HAVAL med 3 iterationer. [2] För att hitta denna kollision krävdes ungefärliga körningar av kontraktionsfunktionen H . $2^{29}$

2004 tillkännagav de kinesiska forskarna Wang Xiaoyun , Feng Dengguo , Lai Xuejia och Yu Hongbo en sårbarhet som de hade upptäckt i HAVAL-128 med tre iterationer som gör att kollisioner kan hittas med HAVAL-beräkningar. [3] $2^7$

2006 genomförde en grupp kinesiska forskare under ledning av Wang Xiaoyun och Yu Hongbo två attacker mot HAVAL med fyra iterationer, vilket också krävde hashoperationer. De föreslog också den första teoretiska attacken på HAVAL med 5-iterationer med antalet hashoperationer ungefär lika med . [fyra] $2^{43}$ $2^{{36}}$ $2^{123}$

Se även

MD5
SHA-1

Anteckningar

↑ Tokareva N. N. Starkt olinjära booleska funktioner: böjda funktioner och deras generaliseringar (otillgänglig länk) (2008). Arkiverad från originalet den 15 februari 2012. (ryska)
↑ Bart Van Rompay, Alex Biryukov, Bart Preneel och Joos Vandewalle. Kryptanalys av 3-pass HAVAL . (inte tillgänglig länk)
↑ Xiaoyun Wang, Dengguo Feng, Xuejia Lai, Hongbo Yu. Kollisioner för hashfunktionerna MD4, MD5, HAVAL-128 och RIPEMD (engelska) (nedlänk) (17 augusti 2004). Arkiverad från originalet den 23 augusti 2011.
↑ Xiaoyun Wang, Aaram Yun, Sangwoo Park, Hongbo Yu. Krypteringsanalys av den fullständiga HAVAL med 4 och 5 pass (engelska) (2006). (inte tillgänglig länk)

Länkar

https://web.archive.org/web/20080905132936/http://labs.calyptix.com/files/haval-paper.pdf – Yuliang Zheng, Josef Pieprzyk och Jennifer Seberry: “HAVAL är en enkelriktad hashalgoritm med variabel utmatningslängd", 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 (innehåller fast konstant ordning)
Onlineberäkning av HAVAL-hashar

Hash-funktioner
generell mening	Adler-32 CRC Fletcher kontrollsumma FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH - Hashträd jenkins hash hash summa
Kryptografisk	Stribog GOST R 34,11-94 Bälte BLAKE bmw CubeHash EKO edonkey2k FSB Fuga Grostl HAVAL Hamsi J H Kupyna LM hash Luffa MD2 MD4 MD5 MD6 N-hash RIPEMD-128 RIPEMD-160 RIPEMD-256 RIPEMD-320 SHA-1 SHA-2 Keccak (SHA-3) SHABAL SHAvite-3 SIMD SWIFFT Hud Snefru Tiger Bubbelpool
Nyckelgenereringsfunktioner	bcrypt PBKDF2 kryptera Argon 2 Lyra2
Kontrollnummer ( jämförelse )	Kontrollera summan Verhouffs algoritm Månen algoritm Jävla algoritm Streckkod bankkonton bankkort ÄR I SNILS OKPO TENN OKATO ISBN OGRN och OGRNIP VIN
Hashes	Jämförelse av checknummer Autentiseringsprotokoll Streckkodsjämförelse Kryptografi Magnet länk Merkle signatur ed2k URNA