MD5

MD5
Oprettet	1991 _
offentliggjort	april 1992 _
Forgænger	MD4
Efterfølger	SHA-2
Standarder	RFC 1321
Hash størrelse	128 bit
Antal runder	fire
Type	hash funktion

MD5 ( Message Digest 5 ) er en 128 -bit hashing- algoritme udviklet af professor Ronald L. Rivest fra Massachusetts Institute of Technology (MIT) i 1991 . Designet til at skabe "fingeraftryk" eller beskedsammendrag af vilkårlig længde og derefter bekræfte deres ægthed. Det blev i vid udstrækning brugt til at kontrollere integriteten af information og gemme kodeords-hash.

Historie

MD5 er en af en række algoritmer for meddelelsesfordøjelse udviklet af professor Ronald L. Rivest fra Massachusetts Institute of Technology. Den blev udviklet i 1991 som en mere pålidelig version af den tidligere MD4-algoritme [1] . Beskrevet i RFC 1321 [2] . Senere fandt Hans Dobbertin fejl i MD4-algoritmen.

I 1993 viste Bert den Boer og Antoon Bosselaers, at pseudo-kollisioner er mulige i algoritmen, når forskellige initialiseringsvektorer svarer til de samme digests for inputmeddelelsen [3] .

I 1996 annoncerede Hans Dobbertin en kollision i algoritmen [4] , og allerede på det tidspunkt blev det foreslået at bruge andre hashing-algoritmer som Whirlpool , SHA-1 eller RIPEMD-160 .

På grund af den lille hash-størrelse på 128 bit, kan fødselsdagsangreb overvejes . I marts 2004 blev MD5CRK-projektet lanceret med det formål at opdage algoritmesårbarheder ved hjælp af fødselsdagsangrebet . MD5CRK-projektet sluttede den 17. august 2004, da Wang Xiaoyun , Feng Dengguo, Lai Xuejia og Yu Hongbo opdagede sårbarheder i algoritmen [5] .

Den 1. marts 2005 demonstrerede Arjen Lenstra , Wang Xiaoyun og Benne de Weger konstruktionen af to X.509- dokumenter med forskellige offentlige nøgler og den samme MD5-hash [6] .

Den 18. marts 2006 udgav forsker Vlastimil Klima en algoritme, der kan finde kollisioner på et minut på en normal computer, metoden kaldes "tunneling" [7] .

I slutningen af 2008 opfordrede US-CERT softwareudviklere, webstedsejere og brugere til at stoppe med at bruge MD5 til ethvert formål, da undersøgelser havde vist, at algoritmen var upålidelig [8] .

Den 24. december 2010 introducerede Tao Xie og Feng Dengguo først en one-block (512-bit) beskedkollision [9] . Tidligere blev der fundet kollisioner for beskeder på to eller flere blokke. Senere gentog Marc Stevens succesen ved at udgive blokke med den samme MD5-hash, samt en algoritme til at opnå sådanne kollisioner [10] .

I 2011 blev hvidbogen RFC 6151 udgivet . Han anerkender MD5 [2] hashing-algoritmen som usikker til nogle formål og anbefaler, at dens brug opgives til fordel for SHA-2.

MD5 algoritme

Algoritmens input modtager en inputdatastrøm, hvis hash skal findes. Meddelelseslængden måles i bits og kan være hvad som helst (inklusive nul). Lad os skrive længden af beskeden i L . Dette tal er heltal og ikke-negativt. Antallet af tal er valgfrit. Efter dataene ankommer, begynder processen med at forberede strømmen til beregninger.

Nedenfor er de 5 trin i algoritmen [2] :

Trin 1: Flowjustering

Først tilføjes en enkelt bit til slutningen af strømmen.

Derefter tilføjes et vist antal nul bit, således at den nye strømlængde bliver sammenlignelig med 448 modulo 512, ( ). Justering sker under alle omstændigheder, selvom længden af den originale strøm allerede er sammenlignelig med 448. $L'$ $L'=512\ gange N+448$

Trin 2. Tilføjelse af en beskedlængde

En 64-bit repræsentation af datalængden (antallet af bits i meddelelsen) tilføjes til slutningen af meddelelsen før justering. Først skrives de lave 4 bytes, derefter de høje. Hvis længden overstiger , tilføjes kun de mindst signifikante bits (svarende til at tage modulo ). Derefter vil længden af strømmen blive et multiplum af 512. Beregningerne vil være baseret på repræsentationen af denne datastrøm som et array af ord på 512 bit. $2^{64}-1$ $2^{64}$

Trin 3 Bufferinitialisering

Til beregninger initialiseres fire 32-bit variabler, hvis begyndelsesværdier er angivet i hexadecimale tal ( little-endian byte rækkefølge ):

A = 01 23 45 67; // 67452301h B = 89 AB CD EF; //EFCDAB89h C = FE DC BA 98; // 98BADCFEh D = 76 54 32 10. // 10325476h

Disse variabler vil gemme resultaterne af mellemliggende beregninger. Starttilstanden ABCD kaldes initialiseringsvektoren.

Trin 4. Beregning i en løkke

Lad os definere de funktioner og konstanter, vi har brug for til beregninger.

Hver runde vil kræve sin egen funktion. Vi introducerer funktioner af tre parametre - ord, resultatet vil også være et ord:

1. etape :,

\operatørnavn {FunF} (X,Y,Z)=(X\kile Y)\vee (\neg X\kile Z)

2. etape: ,

\operatørnavn {FunG} (X,Y,Z)=(X\kile Z)\vee (\neg Z\kile Y)

3. trin: ,

\operatørnavn {FunH} (X,Y,Z)=X\oplus Y\oplus Z

4. etape :,

\operatørnavn {FunI} (X,Y,Z)=Y\oplus (\neg {Z}\vee X)

hvor bitvise logiske operationer er henholdsvis XOR , AND , OR og NOT .

\oplus ,\wedge ,\vee ,\neg

Lad os definere en tabel med konstanter - en datatabel med 64 elementer bygget som følger: . [elleve] $T[1\ldprikker 64]$ $T[n]=\operatørnavn {int} (2^{32}\cdot |\sin n|)$
Hver 512-bit blok gennemgår 4 trin af 16 runder. For at gøre dette er blokken repræsenteret som et array X på 16 ord på 32 bit. Alle runder er af samme type og har formen: [abcd ksi], defineret som , hvor k er tallet på et 32-bit ord fra den aktuelle 512-bit beskedblok, og er et venstre cyklisk skift med s bit af det modtagne 32-bit argument. Tallene s indstilles separat for hver runde. $a=b+((a+\operatørnavn {Sjov} (b,c,d)+X[k]+T[i])\lll s)$ $\ldots \lll s$

Vi indtaster element n fra rækken af 512-bit blokke i datablokken. Værdierne af A, B, C og D, der er tilbage efter operationer på de foregående blokke, gemmes (eller deres startværdier, hvis blokken er den første).

AA=A B.B.=B CC=C DD=D

Scene 1

/* [abcd ksi] a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ [ABCD 0 7 1][DABC 1 12 2][CDAB 2 17 3][BCDA 3 22 4] [ABCD 4 7 5][DABC 5 12 6][CDAB 6 17 7][BCDA 7 22 8] [ABCD 8 7 9][DABC 9 12 10][CDAB 10 17 11][BCDA 11 22 12] [ABCD 12 7 13][DABC 13 12 14][CDAB 14 17 15][BCDA 15 22 16]

Etape 2

/* [abcd ksi] a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ [ABCD 1 5 17][DABC 6 9 18][CDAB 11 14 19][BCDA 0 20 20] [ABCD 5 5 21][DABC 10 9 22][CDAB 15 14 23][BCDA 4 20 24] [ABCD 9 5 25][DABC 14 9 26][CDAB 3 14 27][BCDA 8 20 28] [ABCD 13 5 29][DABC 2 9 30][CDAB 7 14 31][BCDA 12 20 32]

Etape 3

/* [abcd ksi] a = b+ ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ [ABCD 5 4 33][DABC 8 11 34][CDAB 11 16 35][BCDA 14 23 36] [ABCD 1 4 37][DABC 4 11 38][CDAB 7 16 39][BCDA 10 23 40] [ABCD 13 4 41][DABC 0 11 42][CDAB 3 16 43][BCDA 6 23 44] [ABCD 9 4 45][DABC 12 11 46][CDAB 15 16 47][BCDA 2 23 48]

Etape 4

/* [abcd ksi] a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ [ABCD 0 6 49][DABC 7 10 50][CDAB 14 15 51][BCDA 5 21 52] [ABCD 12 6 53][DABC 3 10 54][CDAB 10 15 55][BCDA 1 21 56] [ABCD 8 6 57][DABC 15 10 58][CDAB 6 15 59][BCDA 13 21 60] [ABCD 4 6 61][DABC 11 10 62][CDAB 2 15 63][BCDA 9 21 64]

Vi opsummerer med resultatet af den foregående cyklus:

A=AA+A B=BB+B C=CC+C D=DD+D

Efter afslutningen af cyklussen skal du kontrollere, om der stadig er blokke til beregninger. Hvis ja, så gå til næste element i arrayet ( n + 1) og gentag løkken.

Trin 5. Beregningsresultat

Resultatet af beregningerne er i ABCD-bufferen, dette er hashen. Hvis vi udsender byte for byte, startende med den lave byte A og slutter med den høje byte D, så får vi en MD5-hash. 1, 0, 15, 34, 17, 18...

Pseudokode

// Alle variabler er 32-bit heltal uden fortegn. Alle tilføjelser udføres modulo 2^32. var int s [ 64 ] , K [ 64 ] var int i // s angiver skiftværdierne for hver operation: s [ 0 .. 15 ] := { 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12 , 17, 22 } s [ 16 .. 31 ] := { 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20 } s [ 32 .. 47 ] := { 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23 } s [ 48 .. 63 ] := { 6 , 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21} // Definer en tabel med konstanter som denne for i fra 0 til 63 do K [ i ] := floor ( 2 ^ 32 × abs ( sin ( i + 1 ))) end for // (Eller brug bare forudberegnede værdier): K [ 0 .. 3 ] : = { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee} k [ 4 .. 7 ] : = { 0xf57c0faf , 0x4787c62a, 0xa8304613, 0xfd13, 0x6988d4 : = { 0x6 , .. 15 ] : = {0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821} k [ 16 .. 19 ] : = { ]22..20[k0xf61e2562, 0xc040b340, 0x265a5a5a5a5a, 0xe9b6c7a} k [ 24 .. 27 ] : = { 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed } k [ 28 .. 31 ] : = { 0xa9e3e905 , 0xfcefa3f8 , 0x6 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c } K [ 36 .. 39 ] := { 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 } K [ 40 .. 43 ] := { 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 } K [ 44 .. 47 ] := { 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc 4ac5665} K [ 48 .. 51 ] : = { 0xf4292244, 0x432AFF97, 0xab9423A7 , 0xfc93a039 } K [ 52 .. 55 ] : = { 0x655b59c . 56 .. 56 .. 56 ... 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 } K [ 60 .. 63 ] := { 0xf7537e82, 0xbd3af207, 0xbd3af207, 9bd, 3d, 6d} // Initialiser variabler: var int a0 := 0 x67452301 // A var int b0 := 0 xefcdab89 // B var int c0 := 0 x98badcfe // C var int d0 := 0 x10325476 // D // Forbered: Tilføj en "1" bit til slutningen af beskeden. tilføj " 1 " bit til meddelelsen // Bemærk: inputbytene er repræsenteret som en streng af bits, // hvor den første bit er big-endian. // Forberedelse: tilføj nul bit indtil meddelelseslængden er sammenlignelig med 448 modulo 512 tilføj " 0 " bit indtil meddelelseslængde i bits ≡ 448 ( mod 512 ) // Tilføj resten af den oprindelige meddelelseslængde divideret med 2^64 tilføje original længde i bit mod 2 ^ 64 til besked // Opdel den forberedte meddelelse i 512-bit "bidder": For hver 512 - bit bidder af polstret meddelelse skal du // og arbejde med hver enkelt fragment i seksten 32 - bit ord M [ j ] , 0 ≤ j ≤ 15 / / bryd "stykket" i 16 blokke af 32 bit // Initialiser variablerne for det aktuelle stykke: var int A := a0 var int B := b0 var int C := c0 var int D := d0 // Grundlæggende operationer : for i fra 0 til 63 varierer F , g hvis 0 ≤ i ≤ 15 så F := ( B og C ) eller ( ( ikke B ) og D ) g : = i ellers hvis 16 ≤ i ≤ 31 så F := ( D og B ) eller (( ikke D ) og C ) g := ( 5 × i + 1 ) mod 16 ellers hvis 32 ≤ i ≤ 47 så F := B xor C xor D g := ( 3 × i + 5 ) mod 16 ellers hvis 48 ≤ i ≤ 63 så F := C xor ( B eller ( ikke D )) g := ( 7 × i ) mod 16 F := F + A + K [ i ] + M [ g ] // M[g] - 32 bit blok A := D D := C C := B B := B + ( F <<< s [ i ]) // Udfør en bitskiftende afslutning for // Tilføj resultatet af det aktuelle "stykke" til det samlede resultat a0 := a0 + A b0 := b0 + B c0 := c0 + C d0 := d0 + D slut for var char digest [ 16 ] := a0 tilføje b0 tilføje c0 tilføje d0 // (Little-endian resultat)

Sammenligning af MD5 og MD4

MD5-algoritmen er afledt af MD4. Endnu en runde blev tilføjet til den nye algoritme, nu er der 4 i stedet for 3 i MD4. Tilføjet en ny konstant for at minimere virkningen af inputmeddelelsen, i hver runde ved hvert trin, og hver gang konstanten er anderledes, summeres den med resultatet F og datablokken. Funktionen er ændret i stedet for . Resultatet af hvert trin føjes til resultatet af det foregående trin, på grund af dette er der en hurtigere ændring i resultatet. Til samme formål er mængden af skift på hver cirkel optimeret. Rækkefølgen af arbejdet med inputord i runde 2 og 3 er ændret [2] . $G = XZ \vee (Y \neg Z)$ $XY \vee XZ \vee YZ$

Eksempler på MD5 hashes

Hashen indeholder 128 bits (16 bytes) og er normalt repræsenteret som en sekvens af 32 hexadecimale cifre [12] .

Nogle hash-eksempler:

MD5("md5") = 1BC29B36F623BA82AAF6724FD3B16718

Selv en lille ændring i inputmeddelelsen (i vores tilfælde med en bit: ASCII-tegn "5" med kode 35 16 = 00011010 1 2 erstattes af tegn "4" med kode 34 16 = 00011010 0 2 ) fører til en komplet ændring i hashen. Denne egenskab ved algoritmen kaldes lavineeffekten .

MD5("md4") = C93D3BF7A7C4AFE94B64E30C2CE39F4F

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

MD5("") = D41D8CD98F00B204E9800998ECF8427E

Krypteringsanalyse

I øjeblikket er der flere typer af "hacking" MD5-hash - valg af en besked med en given hash [13] [14] :

I dette tilfælde kan ordbogssøgning og brute-force-metoder bruges til at knække hashen af andre hash-funktioner (med mindre ændringer af algoritmen). I modsætning til dem kræver RainbowCrack præ-forberedelse af regnbuetabeller , som er skabt til en foruddefineret hash-funktion. Kollisionsdetektion er specifik for hver algoritme.

Brute force angreb

Du kan bruge programmerne PasswordsPro [15] , MD5BFCPF [16] , John the Ripper til fuld opregning eller ordbogsoptælling . Der findes færdige ordbøger til at sortere i ordbogen [17] . Den største ulempe ved denne type angreb er den høje beregningsmæssige kompleksitet.

RainbowCrack er en anden metode til at finde forbilledet af en hash fra et givet sæt. Det er baseret på generering af kæder af hashes for at søge efter en given hash ved hjælp af den resulterende database. Selvom skabelsen af regnbueborde tager meget tid og hukommelse, er den efterfølgende revnedannelse meget hurtig. Hovedideen med denne metode er at opnå et kompromis mellem tabelopslagstid og hukommelsesfodaftryk .

MD5-kollisioner

En hash-kollision får den samme funktionsværdi for forskellige meddelelser og en identisk startbuffer. I modsætning til kollisioner er pseudo -kollisioner defineret som ens hashværdier for forskellige værdier af den indledende buffer, og selve beskederne kan være ens eller forskellige. I MD5 er spørgsmålet om kollisioner ikke løst [14] .

I 1996 fandt Hans Dobbertin pseudo-kollisioner i MD5 ved hjælp af visse ikke-standard initialiseringsvektorer . Det viste sig, at det er muligt at bygge en anden besked til en kendt besked, sådan at den vil have samme hash som den originale. Ud fra et matematisk synspunkt betyder det: MD5(IV,L1) = MD5(IV,L2), hvor IV er startværdien af bufferen, og L1 og L2 er forskellige meddelelser. For eksempel, hvis vi tager startværdien af bufferen [4] :

A=0x12AC2375 B=0x3B341042 C=0x5F62B97C D=0x4BA763E

og indstil inputmeddelelsen

AA1DDABE	D97ABFF5	BBF0E1C1	32774244
1006363E	7218209D	E01C136D	9DA64D0E
98A1FB19	1FAE44B0	236BB992	6B7A779B
1326ED65	D93E0972	D458C868	6B72746A

derefter ved at tilføje et tal til et bestemt 32-bit ord i blokbufferen, kan du få en anden besked med den samme hash. Hans Dobbertin introducerede følgende formel: $2^9$

L2_{i}={\begin{cases}L1_{i},&i\neq 14;\\L1_{i}+2^{9},&i=14.\end{cases}}

Derefter MD5(IV, L1) = MD5(IV, L2) = BF90E670752AF92B9CE4E3E1B12CF8DE.

I 2004 annoncerede de kinesiske forskere Wang Xiaoyun Yu Hongbo en sårbarhed, de havde opdaget i en algoritme, der gjorde det muligt for dem atog Lai Xuejia, Feng Dengguo, ) finde kollisioner [5] [18] .

I 2005 udgav Wang Xiaoyun og Yu Hongbo fra Shandong University i Kina en algoritme, der kan finde to forskellige 128-byte-sekvenser, der producerer den samme MD5-hash. Et af disse par (særskilte bits fremhævet):

d131dd02c5e6eec4693d9a0698aff95c	2fcab5 8 712467eab4004583eb8fb7f89
55ad340609f4b30283e4888325 7 1415a	085125e8f7cdc99fd91dbd f 280373c5b
d8823e3156348f5bae6dacd436c919c6	dd53e2 b 487da03fd02396306d248cda0
e99f33420f577ee8ce54b67080 a 80d1e	c69821bcb6a8839396f965 2b6ff72a70 _

d131dd02c5e6eec4693d9a0698aff95c	2fcab5 0 712467eab4004583eb8fb7f89
55ad340609f4b30283e4888325 f 1415a	085125e8f7cdc99fd91dbd 7 280373c5b
d8823e3156348f5bae6dacd436c919c6	dd53e2 3 487da03fd02396306d248cda0
e99f33420f577ee8ce54b67080 2 80d1e	c69821bcb6a8839396f965 a b6ff72a70

Hver af disse blokke giver en MD5-hash på 79054025255fb1a26e4bc422aef54eb4 [19] .

I 2006 udgav den tjekkiske forsker Vlastimil Klima en algoritme, der gør det muligt at finde kollisioner på en konventionel computer med enhver initial vektor (A,B,C,D) ved hjælp af en metode, han kaldte " tunneling " [7] [20] .

MD5-algoritmen bruger den iterative Merkle-Damgor-metode , så det bliver muligt at bygge kollisioner med det samme, forudvalgte præfiks. På samme måde opnås kollisioner ved at tilføje det samme suffiks til to forskellige præfikser, der har samme hash. I 2009 blev det vist, at der for to forudvalgte præfikser kan findes specielle suffikser, med hvilke beskeder vil have samme hashværdi. Kompleksiteten af et sådant angreb er kun 2 39 hash-beregninger [21] .

Metoden af Wang Xiaoyun og Yu Hongbo

Metoden af Wang Xiaoyun og Yu Hongbo bruger det faktum, at MD5 er bygget på den iterative Merkle-Damgor metode. Inputfilen udfyldes først, så dens længde er et multiplum af 64 bytes, derefter opdeles den i blokke på hver 64 bytes , , , . Dernæst beregnes sekvensen af 16-byte tilstande , , ifølge reglen , hvor er en eller anden fast funktion. Starttilstanden kaldes initialiseringsvektoren . $M_{0}$ $M_{1}$ $\dots {}$ ${\displaystyle M_{n-1))$ ${\displaystyle s_{0))$ $\dots {}$ $s_{n}$ $s_{i+1}=f\left(s_{i},M_{i}\right)$ $f$ ${\displaystyle s_{0))$

Metoden gør det muligt for en given initialiseringsvektor at finde to par og , sådan at . Denne metode virker for enhver initialiseringsvektor, ikke kun standardvektoren. $M, M'$ $N,N'$ $f(f(s,M),M')=f(f(s,N),N')$

Dette angreb er en variation af differentialangrebet , som i modsætning til andre angreb af denne type bruger heltalssubtraktion frem for XOR som forskelsmål. Ved søgning efter kollisioner bruges meddelelsesmodifikationsmetoden: først vælges en vilkårlig meddelelse , derefter modificeres den efter nogle regler formuleret i artiklen, hvorefter hash-funktionsdifferentialet i øvrigt beregnes med sandsynlighed . Til og anvende kompressionsfunktionen for at kontrollere for kollisionsforhold; derefter vælges en vilkårlig , modificeret, en ny differens beregnes, lig med nul med sandsynlighed , og ligheden af hash-funktionen differens til nul betyder blot tilstedeværelsen af en kollision. Det viste sig, at efter at have fundet et par og , kan du kun ændre de to sidste ord i , derefter for at finde et nyt par og , kun om hashing-operationer kræves [19] . $M_{0}$ $M'_{0}=M_{0}+dM_{0}$ ${2}^{-37}$ $M_{0}$ $M'_{0}$ $M_{1}$ ${2}^{-30}$ $M_{0}$ $M'_{0}$ $M_{0}$ $M_{1}$ $M'_{1}$ ${2}^{39}$

Ved at anvende dette angreb på MD4 kan du finde en kollision på mindre end et sekund. Det gælder også for andre hash-funktioner såsom RIPEMD og HAVAL [5] .

Eksempler på brug

Tidligere mente man, at MD5 giver dig mulighed for at få en relativt pålidelig identifikator for en datablok. I øjeblikket anbefales denne hash-funktion ikke til brug, da der er måder at finde kollisioner med acceptabel beregningskompleksitet [14] [22] .

Egenskaben hash unikke er meget brugt i forskellige områder [23] . De angivne eksempler gælder også for andre kryptografiske hashfunktioner .

Ved at bruge MD5 kontrollerede vi integriteten og ægtheden af de downloadede filer - for eksempel kommer nogle programmer med en kontrolsumværdi . For eksempel pakker til installation af gratis software [24] .

MD5 blev brugt til hashing af password. I et UNIX -system har hver bruger en adgangskode, og kun brugeren kender den. Hashing bruges til at beskytte adgangskoder. Det blev antaget, at den eneste måde at få det rigtige kodeord på var ved en udtømmende søgning. Da UNIX dukkede op, var DES (Data Encryption Standard) den eneste hashmetode , men kun amerikanske beboere kunne bruge den , fordi DES -kildekoder ikke kunne tages ud af landet. FreeBSD løste dette problem. Amerikanske brugere kunne bruge DES- biblioteket , og andre brugere har den tilladte metode til eksport. Derfor begyndte FreeBSD at bruge MD5 som standard. [25] . Nogle Linux- systemer bruger også MD5 til at gemme adgangskoder [26] .

Mange systemer bruger databaser til at godkende brugere, og der er flere måder at gemme adgangskoder på [27] :

Adgangskoder gemmes som de er. Når en sådan database hackes, vil alle adgangskoder blive kendt.
Kun kodeords-hasher gemmes. Du kan finde adgangskoder ved hjælp af forhåndsforberedte hashtabeller. Sådanne tabeller består af hashes af simple eller populære adgangskoder.
Et antal tilfældige tegn (kaldet et " salt ") føjes til hver adgangskode , og resultatet hashes. Den resulterende hash sammen med "saltet" opbevares i det klare. At finde en adgangskode ved hjælp af tabeller ved hjælp af denne metode virker ikke.

Der er flere tilføjelser til MD5.

MD5 ( HMAC ) - Keyed-Hashing for Message Authentication (hashing med en nøgle til meddelelsesgodkendelse) - algoritmen giver dig mulighed for at hashe inputmeddelelsen L med en eller anden nøgle K, sådan hashing giver dig mulighed for at autentificere signaturen [28] .
MD5 ( Base64 ) - her er den resulterende MD5-hash kodet med Base64-algoritmen.
MD5 (Unix) - algoritmen kalder standard MD5 tusind gange for at komplicere processen. Også kendt som MD5crypt [29] .

Noter

↑ Hvad er MD2, MD4 og MD5? (engelsk) (utilgængeligt link) . RSA Laboratories (2000). Hentet 11. juli 2009. Arkiveret fra originalen 23. august 2011.
↑ 1 2 3 4 Rivest, 1992 .
↑ Boer, Bosselaers, 1993 .
↑ 12 Hans Dobbertin . Status for MD5 efter et nyligt angreb . Hentet: 22. oktober 2015. (ubestemt)
↑ 1 2 3 Xiaoyun Wang, Dengguo Feng, Xuejia Lai, Hongbo Yu. Kollisioner for Hash-funktionerne MD4, MD5, HAVAL-128 og RIPEMD (engelsk) (downlink) (17. august 2004). Hentet 19. november 2008. Arkiveret fra originalen 23. august 2011.
↑ Arjen Lenstra, Xiaoyun Wang og Benne de Weger. Kolliderende X.509-certifikater . eprint.iacr.org (1. marts 2005). Dato for adgang: 4. december 2015. Arkiveret fra originalen 4. marts 2016. (ubestemt)
↑ 1 2 Vlastimil Kli'ma. Tunneler i hash-funktioner: MD5-kollisioner inden for et minut (engelsk) (utilgængeligt link) (17. april 2006). Hentet 19. november 2008. Arkiveret fra originalen 23. august 2011.
↑ CERT-sårbarhedsnotat VU #836068 . kb.cert.org (30. december 2008). Hentet 10. oktober 2015. Arkiveret fra originalen 26. juli 2011.
↑ Tao Xie, Dengguo Feng. Konstruer MD5-kollisioner med kun en enkelt beskedblok (PDF) (16. december 2010). Hentet 16. oktober 2015. Arkiveret fra originalen 14. maj 2017. (ubestemt)
↑ Marc Stevens - Forskning - Enkeltblok kollisionsangreb på MD5 . Marc-stevens.nl (2012). Hentet 16. oktober 2015. Arkiveret fra originalen 15. maj 2017. (ubestemt)
↑ Tabellen indeholder med andre ord 32 bits efter decimaltegnet fra værdierne af sin funktion , hvor argumentet n er i radianer.
↑ Registrering af phishing-websteder og sikre transaktioner (link ikke tilgængeligt) . Anna Universitet (2012). Dato for adgang: 20. oktober 2015. Arkiveret fra originalen 4. marts 2016. (ubestemt)
↑ Ah Kioon, Wang, Deb Das, 2013 .
↑ 1 2 3 Opdaterede sikkerhedsovervejelser for MD5 Message-Digest og HMAC-MD5 algoritmerne . Internet Engineering Task Force (marts 2011). Hentet 23. oktober 2015. Arkiveret fra originalen 15. juni 2017. (ubestemt)
↑ PasswordsPro (downlink) . Inside Pro Software. — Et program til gendannelse af adgangskoder til hashes af forskellige typer. Hentet 19. november 2008. Arkiveret fra originalen 27. august 2011. (ubestemt)
↑ MD5-projekt på SourceForge.net
↑ CERIAS - Sikkerhedsarkiv . Center for Uddannelse og Forskning i Informationssikring og Sikkerhed (juni 2000). Hentet 19. november 2008. Arkiveret fra originalen 7. december 2008. (ubestemt)
↑ Philip Hawkes, Michael Paddon, Gregory G. Rose. Musings on the Wang et al. MD5 Collision (engelsk) (utilgængeligt link) (13. oktober 2004). Hentet 19. november 2008. Arkiveret fra originalen 23. august 2011.
↑ 12 Wang , Yu, 2005 .
↑ Vlastimil Klima. MD5-kollisioner (engelsk) (utilgængeligt link) . Hentet 19. november 2008. Arkiveret fra originalen 23. august 2011.
↑ Stevens, Lenstra, Weger, 2012 .
↑ Marc Stevens, Arjen Lenstra og Benne de Weger. Softwareintegritets- og kodesigneringsapplikationers sårbarhed over for kollisioner med udvalgte præfikser for MD5 (30. november 2007). Hentet 25. oktober 2015. Arkiveret fra originalen 13. december 2007. (ubestemt)
↑ Ilya Mironov. Hash-funktioner: Teori, angreb og applikationer . Microsoft Research (14. november 2005). Hentet 13. november 2015. Arkiveret fra originalen 4. marts 2016. (ubestemt)
↑ Turnbull J. Hardening Linux (engelsk) - 1 - Apress , 2005. - S. 57-58.
↑ Bill Swingle. FreeBSD-håndbog (DES, MD5 og kryptering) (link ikke tilgængeligt) (2006). Hentet 20. november 2008. Arkiveret fra originalen 17. september 2009. (ubestemt)
↑ Vicki Stanfield, Roderick W. Smith. Linux System Administration (Craig Hunt Linux Library). - 2. - Sybex, 2002. - S. 479-483. — 656 s. — ISBN 978-0782141382 .
↑ Hossein Bidgoli. The Internet Encyclopedia, bind 3. - 1. - Wiley, 2003. - S. 3-4. — 908 s. — ISBN 978-0471222019 .
↑ Krawczyk, Hugo, Canetti, Ran, Bellare, Mihir. HMAC: Keyed-Hashing til meddelelsesgodkendelse . tools.ietf.org. Hentet 5. december 2015. Arkiveret fra originalen 15. april 2021. (ubestemt)
↑ Steve Alexander. adgangskodebeskyttelse til moderne operativsystemer . USENIX 2004 (juni 2004). Hentet 5. december 2015. Arkiveret fra originalen 8. december 2015. (ubestemt)

Litteratur

Rivest R. The MD5 Message-Digest Algorithm (engelsk) - IETF , 1992. - 21 s. doi : 10.17487/RFC1321
Boer B. d. , Bosselaers A. Collisions for the compression function of MD5 (engelsk) // Advances in Cryptology - EUROCRYPT '93 : Workshop on the Theory and Application of Cryptographic Techniques Lofthus, Norge, 23.-27. maj 1993 Proceedings / T. Helleseth - 1 - Berlin : Springer Berlin Heidelberg , 1993. - S. 293-304. — 465 s. — ISBN 978-3-540-57600-6 — doi:10.1007/3-540-48285-7_26
Xiaoyun W. , Yu H. How to Break MD5 and Other Hash Functions // Fremskridt inden for kryptologi - EUROCRYPT 2005 : 24th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Aarhus, Danmark, 22.-26. maj 2005. Proceedings / R. Cramer - Springer Science + Business Media , 2005. - S. 19-35. — 578 s. — ISBN 978-3-540-25910-7 — doi:10.1007/11426639_2
Stevens M. , Lenstra A. K. , Weger B. d. Kollisioner med valgt præfiks for MD5 og applikationer (engelsk) // International Journal of Applied Cryptography - Inderscience Publishers , 2012. - Vol. 2, Iss. 4. - S. 322-359. — ISSN 1753-0563 ; 1753-0571 - doi:10.1504/IJACT.2012.048084
Cindy A. K. M. , Wang Z. , Deb Das S. Sikkerhedsanalyse af MD5-algoritme i adgangskodelagring (engelsk) // Applied Mechanics and Materials - 2013. - Vol. 2706-2711. — ISSN 1660-9336 ; 1662-7482 ; 2297-8941 - doi:10.4028/WWW.SCIENTIFIC.NET/AMM.347-350.2706

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