HAVAL

Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den version , der blev gennemgået den 11. maj 2018; checks kræver 6 redigeringer .

HAVAL
Udviklere	Yuliang Zheng , Josef Pieprzyk , Jennifer Seberry
Oprettet	1992
offentliggjort	1992
Hash størrelse	128, 160, 192, 224, 256 bit
Antal runder	96, 128, 160
Type	hash funktion

HAVAL er en kryptografisk hashfunktion udviklet af Yuliang Zheng , Josef Pieprzyk og Jennifer Seberry i 1992 .

Givet en vilkårlig inputmeddelelse genererer funktionen en hashværdi kaldet message digest , som kan være 128, 160, 192, 224 eller 256 bit lang. Antallet af iterationer er variabelt, fra 3 til 5. Antallet af runder ved hver iteration er 32. Det er en modifikation af MD5 .

Algoritme

Lad os definere booleske funktioner , der bruges til at udføre bitvise operationer på ord.
1. iteration 2. iteration 3. iteration 4. iteration 5. iteration Algoritmen modtager en inputdatastrøm, hvis hash skal findes. Denne strøm er opdelt i blokke, hver 1024 bit lange. Følgende er de 3 trin 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}$

Trin 1. Udvid meddelelsen

Først udvides meddelelsen, så dens længde i bit bliver lig med 944 modulo 1024. For at gøre dette skrives en en bit til slutningen af meddelelsen, og derefter det nødvendige antal nul bit. De resterende 80 bit er tilføjet en 64-bit repræsentation af antallet af bit i meddelelsen før justering (MSGLENG-felt), en 10-bit repræsentation af meddelelsessammenfatningslængden (DGSTLENG-felt), en 3-bit repræsentation af antallet af iterationer (PASS-feltet) og en 3-bit repræsentation af HAVAL-versionen ( VERSION-feltet).

Trin 2. Behandling af beskeden i blokke på 1024 bit

Lad os skrive en udvidet meddelelse i formen: , hvor er en 1024-bit blok og n er antallet af blokke i en udvidet meddelelse. For i fra 0 til n-1 udfører vi derefter følgende beregning: , hvor H er komprimeringsfunktionen beskrevet nedenfor og er en 256-bit 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 behandler meddelelsesblokken i 3, 4 eller 5 iterationer (afhængigt af værdien af PASS-feltet). Lad os betegne de kompressionsfunktioner, der bruges i iterationer af og . Lad være en 256-bit konstant, og lad være 256-bit output af funktionen H . Så kan H beskrives som følger (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{hvis 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}}$
(Bemærk: en typeoperation er en operation af formen: , hvor 32-bit ord. $D_{out}=E_{x}\boxplus E_{y};$ $D_{out,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$

Lad os betegne iterationstallet med j (j =1,…,5). Iteration nummer j svarer til komprimeringsfunktionen . Indgangen til hver funktion er og , hvor er en 1024-bit beskedblok bestående af 32 ord , a består af 8 ord . Så kan det skrives som følger: ${\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 . Lade

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

2 . Gentag følgende trin for i fra 0 til 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))

, hvor er 32-bit 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 . Lad og være et 256-bit output .

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: - sammensætning af to funktioner (den første udføres ), $f\circ g$ $g$

\box plus

- addition modulo ,

2^{32}

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

er de permutationer, der er beskrevet i tabel 2.

Bemærk: der bruges ingen konstanter i 1. iteration (dvs. ). $K_{j,i}=0.0\leqslant i\leqslant 31$

I modsætning til iteration 1, behandles den i 2. og efterfølgende iterationer ikke i ordrækkefølge, men i den rækkefølge, der er angivet i tabel 1. $B$

Tabel 1. Tekstbehandlingsrækkefølge

${\displaystyle ord_{1))$ ( ) $H_1$	0	en	2	3	fire	5	6	7	otte	9	ti	elleve	12	13	fjorten	femten	16	17	atten	19	tyve	21	22	23	24	25	26	27	28	29	tredive	31
${\displaystyle ord_{2))$ ( ) $H_2$	5	fjorten	26	atten	elleve	28	7	16	0	23	tyve	22	en	ti	fire	otte	tredive	3	21	9	17	24	29	6	19	12	femten	13	2	25	31	27
$ord_{3}$ ( ) $H_3$	19	9	fire	tyve	28	17	otte	22	29	fjorten	25	12	24	tredive	16	26	31	femten	7	3	en	0	atten	27	13	6	21	ti	23	elleve	5	2
${\displaystyle ord_{4))$ ( ) $H_4$	24	fire	0	fjorten	2	7	28	23	26	6	tredive	tyve	atten	25	19	3	22	elleve	31	21	otte	27	12	9	en	29	5	femten	17	ti	16	13
${\displaystyle ord_{5))$ ( ) $H_{5}$	27	3	21	26	17	elleve	tyve	29	19	0	12	7	13	otte	31	ti	5	9	fjorten	tredive	atten	6	28	24	2	23	16	22	fire	en	25	femten

Tabel 2. Permutationer

	${\displaystyle x_{6))$ $\pil ned$	$x_{5}$ $\pil ned$	$x_{4}$ $\pil ned$	$x_{3}$ $\pil ned$	$x_{2}$ $\pil ned$	$x_{1}$ $\pil ned$	$x_{0}$ $\pil ned$
$\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}$

Trin 3. Dannelse af beskedsammendraget

Dette trin bruger længden på 256 bit opnået i trin 2. Hvis den nødvendige hashstørrelse er 256 bit, er der en meddelelsessammenfatning. Lad os overveje de andre 4 sager. $D_{n}=D_{n,7}D_{n,6}\dots D_{n,0}$ $D_{n}$

1. Hash-størrelse - 128 bit

Lad os sætte det i følgende 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]}

(det hævede skrift angiver længden af X i bits)

Så er beskedsammendraget 128-bit , hvor ${\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. Hash-størrelse - 160 bit

Lad os sætte det i følgende 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]}

Så er beskedsammendraget 160-bit , hvor ${\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. Hash-størrelse - 192 bit

Lad os sætte det i følgende 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]}

Lade

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

4. Hash-størrelse - 224 bit

Lad os præsentere det i følgende 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]}

Så er beskedsammendraget 224-bit , hvor ${\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 brugt i algoritmen

Denne algoritme bruger 136 32-bit konstanter. Lad os skrive dem ned i følgende rækkefølge:

en.

{\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))

fire.

{\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ørste 8 konstanter repræsenterer de første 256 bit af brøkdelen af tallet . Konstanterne svarer til de næste 1024 bit af brøkdelen , og så videre. ${\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 , , og $F_{1}$ $F_{2}$ $F_{3}$ $F_{4}$ $F_{5}$ _

Boolske funktioner , , , og , brugt i algoritmen, har en række nyttige egenskaber i tilfælde af foreløbig permutation af deres argumenter: $F_{1}$ $F_{2}$ $F_{3}$ $F_{4}$ $F_{5}$

1) De er afbalanceret med 0 og 1. Det betyder, at outputtet af funktionen for et vilkårligt sæt af inputdata med lige stor sandsynlighed (1/2) kan være enten 0 eller 1. 2) De er meget ikke-lineære. [en] 3) De opfylder Strict Avalanche- kriteriet, dvs. når værdien af en af inputvariablerne ændres, ændres værdien af funktionen med en sandsynlighed på 1/2. 4) De kan ikke opnås fra hinanden ved at anvende lineære transformationer til inputvariablerne. 5) Dette sæt funktioner er gensidigt ikke-korreleret i output, det vil sige, at ethvert funktionspar er gensidigt ikke-korreleret i output (funktioner og korrelerer ikke indbyrdes i output, hvis , og er afbalanceret med 0 og 1, ikke-lineær funktioner)

f

g

f

g

f\oplus g

HAVAL - hashes

HAVAL-hash er normalt repræsenteret som en sekvens af 32, 40, 48, 56 eller 64 hexadecimale tal.
Nogle hash-eksempler (størrelse - 256 bit, antal iterationer - 5):

HAVAL(" Den hurtige brune ræv hopper over den dovne hund ") = b89c551cdfe2e06dbd4cea2be1bc7d557416c58ebb4d07cbc94e49f710c55be4

Selv en lille ændring i inputmeddelelsen (i vores tilfælde med et tegn: tegnet "d" erstattes af tegnet "c") fører til en fuldstændig ændring i hashen.

HAVAL("Den hurtige brune ræv hopper over det dovne tandhjul") = 60983bb8c8f49ad3bea29899b78cd741f4c96e911bbc272e5550a4f195a4077e

Et eksempel på en HAVAL-hash for en "nul"-streng:

HAVAL("") = be417bb4dd5cfb76c7126f4f8eeb1553a449039307b1a3cd451dbfdc0fbbe330

Sammenligning mellem HAVAL og MD5

I modsætning til MD5-hash-funktionen, som har en fast størrelse på digest og antallet af iterationer, giver HAVAL 15 forskellige algoritmevarianter ved at kombinere digest-længden og antallet af iterationer. Dette giver mere fleksibilitet og gør derfor hash-funktionen mere velegnet til applikationer, der kræver forskellige besked-hash-længder og forskellige sikkerhedsniveauer.
Eksperimenter har vist, at HAVAL er 60 % hurtigere end MD5 ved 3 iterationer, 15 % hurtigere ved 4 iterationer og lige så hurtig ved fem iterationer.

Krypteringsanalyse

Kollisioner HAVAL

En hash-kollision får den samme funktionsværdi for forskellige meddelelser.

I 2003 opdagede Bart Van Rompay, Alex Biryukov , Bart Prenel og Joos Vandewalle en kollision for 3-iteration HAVAL. [2] At finde denne kollision krævede cirka kørsler af kontraktionsfunktionen H . $2^{29}$

I 2004 annoncerede de kinesiske forskere Wang Xiaoyun , Feng Dengguo , Lai Xuejia og Yu Hongbo en sårbarhed, de havde opdaget i 3-iterationen HAVAL-128, der gør det muligt at finde kollisioner ved hjælp af HAVAL-beregninger. [3] $2^7$

I 2006 udførte en gruppe kinesiske videnskabsmænd ledet af Wang Xiaoyun og Yu Hongbo to angreb på 4-iterationen HAVAL, som også krævede henholdsvis hashing-operationer. De foreslog også det første teoretiske angreb på 5-iterations HAVAL med antallet af hash-operationer omtrent lig med . [fire] $2^{43}$ $2^{{36}}$ $2^{123}$

Se også

MD5
SHA-1

Noter

↑ Tokareva N. N. Stærkt ikke-lineære booleske funktioner: bøjede funktioner og deres generaliseringer (utilgængeligt link) (2008). Arkiveret fra originalen den 15. februar 2012. (Russisk)
↑ Bart Van Rompay, Alex Biryukov, Bart Preneel og Joos Vandewalle. Krypteringsanalyse af 3-Pass HAVAL . (utilgængeligt link)
↑ Xiaoyun Wang, Dengguo Feng, Xuejia Lai, Hongbo Yu. Kollisioner for Hash-funktionerne MD4, MD5, HAVAL-128 og RIPEMD (engelsk) (downlink) (17. august 2004). Arkiveret fra originalen den 23. august 2011.
↑ Xiaoyun Wang, Aaram Yun, Sangwoo Park, Hongbo Yu. Krypteringsanalyse af den fulde HAVAL med 4 og 5 gennemløb (engelsk) (2006). (utilgængeligt link)

Links

https://web.archive.org/web/20080905132936/http://labs.calyptix.com/files/haval-paper.pdf – Yuliang Zheng, Josef Pieprzyk og Jennifer Seberry: “HAVAL er en envejs hashing-algoritme med variabel længde af output", 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 (indeholder fast konstant rækkefølge)
Online beregning af HAVAL hashes

Hash funktioner
generelle formål	Adler-32 CRC Fletcher kontrolsum FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH - Hash Tree jenkins hash hash sum
Kryptografisk	Stribog GOST R 34,11-94 Bælte BLAKE bmw CubeHash EKKO edonkey2k FSB Fuge Grostl HAVAL Hamsi JH 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 Whirlpool
Nøglegenereringsfunktioner	bcrypt PBKDF2 krypt Argon 2 Lyra2
Tjek nummer ( sammenligning )	Tjek sum Verhouffs algoritme Månen algoritme Damm algoritme Stregkode bankkonti bankkort ER I SNILS OKPO TIN OKATO ISBN OGRN og OGRNIP VIN
Hashes	Sammenligning af checknumre Autentificeringsprotokoller Stregkode sammenligning Kryptografi Magnet link Merkle signatur ed2k URNE