Lucrare de laborator nr.

Tema: Hash–area MD4

1.1 MD4 este o funcție de hash dezvoltată de Rivest în 1990. Servește ca bază
pentru majoritatea funcțiilor de hash dedicate, cum ar fi MD5, SHAx,
RIPEMD și HAVAL. În 1996, Dobbertin a arătat cum să găsească coliziuni
ale MD4 cu o complexitate echivalentă cu 220 de calcule de hașă MD4. În
acest articol, prezentăm un nou atac asupra MD4, care poate găsi o coliziune
cu probabilitatea 2−2 până la 2−6iar complexitatea găsirii unei coliziuni nu
depășește 28 de operații de hașă MD4. Bazat pe atacul de căutare a coliziunii,
prezentăm un atac de imagine pre-imagine ales pe MD4 cu complexitate sub
28. De asemenea, arătăm că pentru un mesaj slab, putem găsi un alt mesaj care

produce aceeași valoare de hash. Complexitatea este doar un singur calcul

MD4, iar un mesaj aleatoriu este un mesaj slab cu probabilitatea 2−122.

Fiind dat un şir de biţi x, se defineşte tabloul M = M0 M1 . . . MN −1 cu fiecare

Mi (numit cuvânt) de lungime 32 şi N ≡ 0 (mod 16).

1. d ←− (447 − |x|) (mod 512)

2. s ←− reprezentarea binară a lui |x| (mod 264 ), |s| = 64 3. M = xǁ1ǁ0dǁs

Să descriem acum calculul amprentei numerice, codificată pe 128 biţi. Algoritmul
de gene- rare este:
 Amprenta numerică este ı̂n final concatenarea celor patru cuvinte A, B, C, D (numite
re- gistre). Algoritmul ı̂mparte tabelul M ı̂n şiruri de câte 16 cuvinte consecutive, cărora
le aplică trei etape de transformări (ca la DES). Adunările de la pasul 8 sunt efectuate
modulo 232 .
Cele trei etape de transformări sunt distincte (spre deosebire de DES, unde cele 16 etape
erau identice).
Fie α, β două cuvinte de lungimi egale. Etapele de transformări vor folosi
următoarele operaţii:

• α∧ β şi logic bit cu bit (AN D)

• α∨ β sau logic bit cu bit (OR)

• α⊕ β sau exclusiv bit cu bit (XOR)

• ¬α complementara bit cu bit (NOT )

• α+β suma modulo 232

• α << s rotirea circulară cu s biţi spre stânga (1 ≤ s ≤ 31)

Aceste operaţii sunt extrem de rapide şi pot fi implementate direct ţinând cont de
arhitectura calculatorului. Să detaliem puţin acest lucru.
Fie a1 a2 a3 a4 un cuvânt de patru octeţi şi ai un număr ı̂ntreg din intervalul [0, 255].

• Într-o arhitectură big-endian (o staţie SP ARK de exemplu), un cuvânt reprezintă

ı̂ntregul
a1224 + a2216 + a328 + a4

• ˆIntr-o arhitectură little-endian (cum este familia Intel 80xxx), un cuvânt reprezintă
ˆıntregul a4224 + a3216 + a228 + a1

Construcţia standard a lui MD4 a folosit o arhitectură little-endian. Cum amprenta

nu- merică trebuie să fie independentă de arhitectura calculatorului folosit, la o
implementare a lui MD4 pe un calculator big-endian, adunările se vor defini astfel:

1. Se inter-schimbă x1 ↔ x4 , x2 ↔ x3 , y1 ↔ y4 , y2 ↔ y3

2. Se calculează Z = X + Y (mod 232 )

3. Se inter-schimbă z1 ↔ z4 , z2 ↔ z3

Cele trei etape de construcţie ale funcţiei de dispersie MD4 folosesc trei funcţii f, g şi
respectiv
h, definite astfel:
f (X, Y, Z) = (X ∧ Y ) ∨ ((¬X) ∧ Z)
g(X, Y, Z) = (X ∧ Y ) ∨ (X ∧ Z) ∨ (Y ∧ Z)
 h(X, Y, Z) = X ⊕ Y ⊕ Z
Descrierile celor trei etape sunt:
Etapa 1:
1. A ←− (A + f (B, C, D) + X[0]) << 3 9. A ←− (A + f (B, C, D) + X[8])<<3
2. D ←− (D + f (A, B, C) + X[1]) << 7 10. D ←− (D + f (A, B, C) + X[9]) << 7
3. C ←− (C + f (D, A, B) + X[2]) << 11 11. C ←− (C + f (D, A, B) + X[10]) << 11
4. B ←− (B + f (C, D, A) + X[3]) << 19 12. B ←− (B + f (C, D, A) + X[11])<<19
5. A ←− (A + f (B, C, D) + X[4]) << 3 13. A ←− (A + f (B, C, D) + X[12]) << 3
6. D ←− (D + f (A, B, C) + X[5]) << 7 14. D ←− (D + f (A, B, C) + X[13]) << 7
7. C ←− (C + f (D, A, B) + X[6]) << 11 15. C ←− (C + f (D, A, B) + X[14]) <<11
8. B ←− (B + f (C, D, A) + X[7]) << 19 16. B ←− (B + f (C, D, A) + X[15]) << 19
Etapa 2:
1. A ←− (A + g(B, C, D) + X[0] + P ) << 3 9. A ←− (A + g(B, C, D) + X[2] + P ) << 3
2. D ←− (D + g(A, B, C) + X[4] + P ) <<5 10. D ←− (D + g(A, B, C) + X[6] + P )
<<5
3. C ←− (C + g(D, A, B) + X[8] + P ) << 9 11. C ←− (C + g(D, A, B) + X[10] + P )
<<9
4. B ←− (B+g(C, D, A)+X[12]+P ) << 13 12. B ←− (B+g(C, D, A)+X[14]+P ) <<
13
5. A ←− (A + g(B, C, D) + X[1] + P ) << 3 13. A ←− (A + g(B, C, D) + X[3] + P )
<<3
6. D ←− (D + g(A, B, C) + X[5] + P ) << 5 14. D ←− (D + g(A, B, C) + X[7] + P ) <<
5
7. C ←− (C + g(D, A, B) + X[9] + P )<<9 15. C ←− (C + g(D, A, B) + X[11] + P )
<<9
8. B ←− (B+g(C, D, A)+X[13]+P )<<13 16. B ←− (B+g(C, D, A)+X[15]+P ) <<
13
unde s-a notat P = 5A827999.
Etapa 3:
1. A ←− (A + h(B, C, D) + X[0] + P ) << 3 9. A ←− (A + h(B, C, D) + X[1] + P ) << 3
2. D ←− (D + h(A, B, C) + X[8] + P ) << 9 10. D ←− (D + h(A, B, C) + X[9] + P ) <<
9
 3. C ←− (C + h(D, A, B) + X[4] + P ) << 11 11. C ←− (C + h(D, A, B) + X[5] + P )<<
11
4. B ←− (B +h(C, D, A)+X[12]+P ) << 15 12. B ←− (B +h(C, D, A)+X[13]+P ) <<
15
5. A ←− (A + h(B, C, D) + X[2] + P ) << 3 13. A ←− (A + h(B, C, D) + X[3] + P ) <<
3
6. D ←− (D + h(A, B, C)+ X[10]+ P ) << 9 14. D ←− (D + h(A, B, C)+ X[11]+ P )
<<9
7. C ←− (C + h(D, A, B) + X[6] + P ) << 11 15. C ←− (C + h(D, A, B) + X[7] + P ) <<
11
8. B ←− (B +h(C, D, A)+X[14]+P ) << 15 16. B ←− (B +h(C, D, A)+X[15+P ])
<<15 unde P = 6ED9EBA1.

1.2 Funcțiile Hash sunt instrumente utilizate în integritatea mesajelor, a

semnăturilor digitale și a timbrului digital. Algoritmii de digerare a mesajelor au
început cu criptografia cu chei publice pentru autentificare. Algoritmii Digest
calculează unele funcții hash, care sunt valori de digerare a mesajelor bazate pe un
set simplu de operații primitive de cuvinte pe 32 de biți. Printre algoritmii de digest
MD4 și MD5 sunt cei mai populari. Ambii algoritmi efectuează un set de operații
logice bit. Acestea generează valori de digerare pe 128 de biți dintr-un mesaj dat.
Complexitatea în timp a MD5 este mai mare decât MD4 și, prin urmare, ceva mai
lent de executat. Algoritmii de digerare a mesajelor MD4, MD5 au fost discutați în
detaliu. O nouă metodă a fost introdusă pentru obținerea de coliziuni pentru un
număr redus de runde de algoritmi MD4 și MD5. Complexitatea timpului,
performanța și atacurile algoritmului MD4 și MD5 au fost calculate prin această
metodă. Puterea a fost calculată la schimbarea mesajului; noua metodă își poate
dovedi puterea.
 Fig. 1 Operația MD4

O operațiune MD4: MD4 constă din 48 din aceste operațiuni, grupate în trei runde
de 16 operații. F este o funcție neliniară; o funcție este utilizată în fiecare rundă. Mi
denotă un bloc pe 32 de biți din intrarea mesajului, iar Ki denotă o constantă pe 32
de biți, diferită pentru fiecare operație.

MD4 (MESSAGE DIGEST4) - HASHA-RE

Fie un mesaj aleatoriu care intentionam sa fie mesajul pentru parola.

Mesaj: CARAUSVICTORIAAB
01000011 01100001 01110010 01100001 01110101 01110011 01010110 01101001 01100011 01110100 01101111
01110010 01101001 01100001 01000001 01000010

A => 01000011 01100001 01110010 01100001

B => 01110101 01110011 01010110 01101001

C => 01100011 01110100 01101111 01110010

D => 01101001 01100001 01000001 01000010

1. F= B xor C xor D
1111111011001100111100001011001

2.A+F mod 2^32= (01000011 01100001 01110010 01100001 + 01000001 01001100 01000101
01011000)mod2^32= 334330315

3. P(2)+Mi mod 2^32 = (2334330315+0 )mod 2^32 = 2334330315(

10011111011010111100111001011)
4. 10011111011010111100111001011<<<3=10011111011010111100111001011000
5. D=>A=>01000011 01100001 01110010 01100001
A=>B=>10110010 01110100 00110011 00010101
B=>C=>01000001 01001100 01000101 01011000
C=>D=>01000001 01001110 01000100 01010010
1. F= B xor C xor D
10110010011101100011001000011111

2.A+F mod 2^32= (01010101 01000001 01000010 01000011+ 10110010011101100011001000011111

)mod2^32= 129463394

3. P(2)+Mi mod 2^32 = 129463394+1 mod 2^32 = 129463395

4. 00000111101101110111010001100011<<<7=11011011101110100011000110000011
5. D=>A=>01000001 01001110 01000100 01010010
A=>B=>11011011101110100011000110000011
B=>C=>10110010 01110100 00110011 00010101
C=>D=>01000001 01001100 01000101 01011000
1. F= B xor C xor D
11001110100000111101010101010101

2.A+F mod 2^32= (01000001 01001110 01000100 01010010+ 101000100000100100011111001110

)mod2^32= 1775275040

3. P(2)+Mi mod 2^32 = (1775275040+2)mod 2^32 = 1775275042

4. 01101001110100001000110000100010<<<11=10000100011000010001001101001110
5. D=>A=>01000001 01001100 01000101 01011000
A=>B=>10000100011000010001001101001110
B=>C=>11011011101110100011000110000011
C=>D=>10110010 01110100 00110011 00010101
1. F= B xor C xor D
11101101101011110001000111011000

2.A+F mod 2^32= (01000001 01001100 01000101 01011000+ 11101101101011110001000111011000

)mod2^32= 788223792

3. P(2)+Mi mod 2^32 = (788223792+3)mod 2^32 = 788223795

4. 00101110111110110101011100110011<<<19=10111001100110010111011111011010
5. D=>A=>10110010 01110100 00110011 00010101
A=>B=>10111001100110010111011111011010
B=>C=>10000100011000010001001101001110
C=>D=>11011011101110100011000110000011
1. F= B xor C xor D
11010110011101100111110111001001

2.A+F mod 2^32= (10110010 01110100 00110011 00010101+ 11100110010000100101010100010111

)mod2^32= 2562099244

3. P(2)+Mi mod 2^32 = (2562099244+4)mod 2^32 = 2562099248

4. 10011000101101101000100000110000<<<3=11000101101101000100000110000100
5. D=>A=>11011011101110100011000110000011
A=>B=>11000101101101000100000110000100
B=>C=>10111001100110010111011111011010
C=>D=>10000100011000010001001101001110
1. F= B xor C xor D
11111000010011000010010100010000

2.A+F mod 2^32= (11011011101110100011000110000011+ 11111000010011000010010100010000

)mod2^32= 3557185171

3. P(2)+Mi mod 2^32 = (3557185171+5)mod 2^32 = 3557185176

4. 11010100000001100101011010011000<<<7=00000011001010110100110001101010
5. D=>A=>10000100011000010001001101001110
A=>B=>00000011001010110100110001101010
B=>C=>11000101101101000100000110000100
C=>D=>10111001100110010111011111011010
1. F= B xor C xor D
11111000010011000010010100010000

2.A+F mod 2^32= (10000100011000010001001101001110+ 1111111000001100111101000110100

)mod2^32= 57118082

3. P(2)+Mi mod 2^32 = (57118082+6)mod 2^32 = 57118088

4. 00000011011001111000110110001000<<<11=00111100011011000100000000011011
5. D=>A=>10111001100110010111011111011010
A=>B=>00111100011011000100000000011011
B=>C=>00000011001010110100110001101010
C=>D=>11000101101101000100000110000100
1. F= B xor C xor D
11111010111100110100110111110101

2.A+F mod 2^32= (10111001100110010111011111011010+ 11111010111100110100110111110101

)mod2^32= 3029124559

3. P(2)+Mi mod 2^32 = (3029124559+7)mod 2^32 = 3029124566

4. 10110100100011001100010111010110<<<19=00101110101101011010010001100110
5. D=>A=>11000101101101000100000110000100
A=>B=>00101110101101011010010001100110
B=>C=>00111100011011000100000000011011
C=>D=>00000011001010110100110001101010
1. F= B xor C xor D
10001111100101010100000010111

2.A+F mod 2^32= (11000101101101000100000110000100+ 10001111100101010100000010111

)mod2^32= 3618040219

3. P(2)+Mi mod 2^32 = (3618040219+8)mod 2^32 = 3618040227

4. 11010111101001101110100110100011<<<3=10111101001101110100110100011110
5. D=>A=>00000011001010110100110001101010
A=>B=>10111101001101110100110100011110
B=>C=>00101110101101011010010001100110
C=>D=>00111100011011000100000000011011
1. F= B xor C xor D
10101111111011101010100101100011

2.A+F mod 2^32= (10111101001101110100110100011110+ 10101111111011101010100101100011

)mod2^32= 1831204481

3. P(2)+Mi mod 2^32 = (1531204561+9)mod 2^32 = 125467894

4. 01101101001001011111011010001010<<<7=10010010111110110100010100110110
5. D=>A=>00111100011011000100000000011011
A=>B=>10010010111110110100010100110110
B=>C=>10111101001101110100110100011110
C=>D=>00101110101101011010010001100110
1. F= B xor C xor D
1011110011010110001001110

2.A+F mod 2^32= (10010010111110110100010100110110+ 1011110011010110001001110

)mod2^32= 2490691972

3. P(2)+Mi mod 2^32 = (2490691972+10)mod 2^32 = 2490691982

4. 10010100011101001111000110001110<<<11=10100111100011000111010010100011
5. D=>A=>00101110101101011010010001100110
A=>B=>10100111100011000111010010100011
B=>C=>10010010111110110100010100110110
C=>D=>10111101001101110100110100011110
1. F= B xor C xor D
10001000010000000111110010001011

2.A+F mod 2^32= (00101110101101011010010001100110+ 10001000010000000111110010001011

)mod2^32= 3069583601

3. P(2)+Mi mod 2^32 = (3069583601+11)mod 2^32 = 3069583612

4. 10110110111101100010000011111100<<<19=00000111111001011011011110110001
5. D=>A=>10111101001101110100110100011110
A=>B=>00000111111001011011011110110001
B=>C=>10100111100011000111010010100011
C=>D=>10010010111110110100010100110110
1. F= B xor C xor D
110010100100101000011000100100

2.A+F mod 2^32= (10111101001101110100110100011110+ 110010100100101000011000100100

)mod2^32= 4022981442

3. P(2)+Mi mod 2^32 = (4022981442+12)mod 2^32 = 4022981456

4. 11101111110010011101001101010000<<<3=01111110010011101001101010000111
5. D=>A=>10111101001101110100110100011110
A=>B=>01111110010011101001101010000111
B=>C=>10100111100011000111010010100011
C=>D=>10010010111110110100010100110110
1. F= B xor C xor D
1001011001110011010101100010010

2.A+F mod 2^32= (10111101001101110100110100011110+ 1001011001110011010101100010010

)mod2^32= 141621296

3. P(2)+Mi mod 2^32 = (141621296+13)mod 2^32 = 141621309

4. 00001000011100001111100000111101<<<7=00111000011111000001111010000100
 5. D=>A=>10010010111110110100010100110110
A=>B=>00111000011111000001111010000100
B=>C=>01111110010011101001101010000111
C=>D=>10100111100011000111010010100011
1. F= B xor C xor D
11100001101111101111000010100000

2.A+F mod 2^32= (10010010111110110100010100110110+ 11100001101111101111000010100000

)mod2^32= 1958360534

3. P(2)+Mi mod 2^32 = (1958360534+14)mod 2^32 = 1958360548

4. 01110100101110100011010111100100<<<11=11010001101011110010001110100101
5. D=>A=>10100111100011000111010010100011
A=>B=>11010001101011110010001110100101
B=>C=>00111000011111000001111010000100
C=>D=>01111110010011101001101010000111
1. F= B xor C xor D
10010111100111011010011110100110

2.A+F mod 2^32= (10100111100011000111010010100011+ 10010111100111011010011110100110

)mod2^32= 1059724361

3. P(2)+Mi mod 2^32 = (1059724361+15)mod 2^32 = 1059724376

4. 00111111001010100001110001011000<<<19=11100010110000011111100101010000
5. D=>A=>01111110010011101001101010000111
A=>B=>11100010110000011111100101010000
B=>C=>11010001101011110010001110100101
C=>D=>00111000011111000001111010000100
Rezultat: C$^%=-NTU8G#rO>5

Concluzie
Funcțiile Hash sunt instrumente utilizate în integritatea mesajelor, a semnăturilor
digitale și a timbrului digital. MD4 este o funcție de hash care servește ca bază
pentru majoritatea funcțiilor de hash dedicate, cum ar fi MD5, SHAx, RIPEMD și
HAVAL. Toate aceste funcţii de dispersie au avantajul de a fi foarte rapide, deci
practice în semnarea de mesaje lungi.
Bibliografie
1. http://practicalcryptography.com/hashes/md4-hash/
2. https://searchsecurity.techtarget.com/definition/MD4
3. http://xor.pw/
4. https://bit-calculator.com/bit-shift-calculator
5. Curs3 has.pdf