Voir la source de MD5

[[Fichier:Md5 generalview.png|vignette|Vue générale de MD5.]]
Le '''MD5''', pour [[Fonction de hachage cryptographique|Message Digest]] 5, est une [[fonction de hachage cryptographique]] qui permet d'obtenir l'empreinte numérique d'un fichier (on parle souvent de ''message''). Il a été inventé par [[Ronald Rivest]] en [[1991 en informatique|1991]].

Si l'algorithme MD5 présente un intérêt historique important, il est aujourd'hui considéré comme dépassé et absolument impropre à toute utilisation en [[cryptographie]] ou en sécurité<ref>{{lien web|nom1=Chad R|prénom1=Dougherty|titre=Vulnerability Note VU#836068 MD5 vulnerable to collision attacks|url=https://www.kb.cert.org/vuls/id/836068|website=Vulnerability notes database|éditeur=CERT Carnegie Mellon University Software Engineering Institute|consulté le=3 février 2017|date=31 Dec 2008}}</ref>{{,}}<ref>{{lien web|url=http://www.win.tue.nl/hashclash/rogue-ca/ |titre={{lang|en|Creating a rogue CA certificate}} |auteur=Alexander Sotirov, Marc Stevens, [[Jacob Appelbaum]], [[Arjen Lenstra]], David Molnar, Dag Arne Osvik, Benne de Weger |date=30 décembre 2008 |langue=en}}.</ref>. Il est toutefois encore utilisé pour vérifier l'intégrité d'un fichier après un téléchargement.

== Historique ==
MD5 (''{{lang|en|Message {{nobr|Digest 5}}}}'') est une [[fonction de hachage]] cryptographique qui calcule, à partir d'un fichier numérique, son ''empreinte numérique'' (en l'occurrence une séquence de {{unité|128|[[Bit (informatique)|bits]]}} ou {{nombre|32|caractères}} en notation hexadécimale) avec une probabilité très forte que deux fichiers différents donnent deux empreintes différentes.

En 1991, [[Ronald Rivest]] améliore l'architecture de [[MD4]] pour contrer des attaques potentielles qui seront confirmées plus tard par les travaux de [[Hans Dobbertin]].

Cinq ans plus tard, en [[1996 en informatique|1996]], une faille qualifiée de « grave » (possibilité de créer des [[Collision (informatique)|collisions]] à la demande) est découverte et indique que MD5 devrait être mis de côté au profit de fonctions plus robustes comme [[SHA-1]].

En [[2004 en informatique|2004]], une équipe chinoise découvre des [[Collision (informatique)|collisions]] complètes. MD5 n'est donc plus considéré comme sûr au sens cryptographique. On suggère maintenant d'utiliser plutôt des algorithmes tels que [[SHA-2|SHA-256]], [[RIPEMD-160]] ou [[Whirlpool (algorithme)|{{lang|en|Whirlpool}}]].

Cependant, la fonction MD5 reste encore largement utilisée comme outil de vérification lors des téléchargements et l'utilisateur peut valider l'intégrité de la version téléchargée grâce à l'empreinte. Ceci peut se faire avec un programme comme ''md5sum'' pour MD5 et ''sha1sum'' pour SHA-1.

Comme toute fonction de hachage cryptographique, MD5 peut aussi être utilisé pour calculer l'empreinte d'un mot de passe avec la présence d'un ''[[Salage (cryptographie)|sel]]'' permettant de ralentir une [[attaque par force brute]]. Cela a été le système employé dans [[Linux|GNU/Linux]]. Ainsi, plutôt que de stocker les mots de passe dans un fichier, ce sont leurs empreintes MD5 qui étaient enregistrées (SHA-256, SHA-512 -par défaut- ou DES sont maintenant utilisés), de sorte que quelqu'un qui lirait ce fichier ne pourrait pas découvrir les mots de passe. La commande ''{{lang|en|enable secret}}'' des commutateurs et routeurs Cisco utilisait le hachage MD5  pour stocker le mot de passe du mode privilégié dans le [[fichier de configuration]] de l'équipement<ref>{{Ouvrage|langue=fr|langue originale=en|nom1=Wendell Odom|titre=Préparation à la certification CCNA ICND1 et CCENT|sous-titre=Guide de la préparation officiel Deuxième édition|lieu=Paris|éditeur=[[Pearson (maison d'édition)|PEARSON]]|année=2007|numéro d'édition=CCIE 1624|pages totales=662|passage=265|isbn=978-2-7440-7285-7|numéro chapitre=9|titre chapitre=Configuration des commutateurs Ethernet}}{{Commentaire biblio|à voir en première ligne de la page.}}</ref>. Les dernières versions{{Quand|date=17 janvier 2025}} d'[[Cisco IOS|IOS]] intègrent le hachage SHA256. Cependant, il est recommandé aujourd'hui d'utiliser des fonctions de hachage destinées au stockage des mots passe telles que [[bcrypt]], [[scrypt]] ou [[Argon2]], car elles ont l'avantage d'être lentes, ce qui ralentit l'adversaire souhaitant attaquer les mots de passe.

Le programme {{lang|en|[[John the ripper]]}} permet de casser (inverser la fonction pour) les MD5 triviaux par force brute. Il est incommode pour les clés longues, et ne fonctionne pas toujours si elles contiennent des caractères nationaux spécifiques (cela dépend en fait des dictionnaires utilisés).

Les ''{{lang|en|[[rainbow table]]s}}'' (à accès direct, et qui font parfois plusieurs gigaoctets) permettent de les craquer souvent en moins d'une seconde. Ces tables utilisent des dictionnaires établis après plusieurs jours, mois ou années de calcul. Ceux-ci ne contiennent pas la totalité des clés MD5 possibles, ni ne sont destinés à un cassage par force brute (une empreinte comporte {{nombre|128|bits}}, ce qui représente environ {{nombre|400|sextillions}} (<math>4.10^{38}</math>) de combinaisons), mais permettent par examen de l'empreinte d'éliminer de très grandes classes de combinaisons à ''ne pas'' tester, ce qui accélère la recherche plusieurs milliards de fois. L'efficacité des tables arc-en-ciel diminue si l'empreinte est calculée avec un « sel ».

== Exemple ==
Voici l'empreinte (appelée abusivement ''signature'') obtenue sur une phrase : 
:<tt>MD5("Et l’unique cordeau des trompettes marines")</tt> = <tt>8747e564eb53cb2f1dcb9aae0779c2aa</tt>
En modifiant un caractère, cette empreinte change radicalement : 
:<tt>MD5("Et l’unique cordeau des trompettes marinEs")</tt> = <tt>c802e1bd9b5f2b0d244bbc982f5082b3</tt>

Très concrètement, la vérification de l'empreinte ou [[somme de contrôle]] MD5 peut être réalisée de la façon suivante : lors du téléchargement d'un programme, on note la série de caractères nommée « Signature MD5 » indiquée sur la page de téléchargement. Quand ce téléchargement est terminé, on lance un utilitaire de calcul MD5 comme ''HashCalc'', ''md5sums'' ([[Microsoft Windows|Windows]]) ou ''md5sum'' (Linux), qui indique entre autres la somme de contrôle correspondant au fichier. Si les deux valeurs correspondent, on peut alors raisonnablement considérer que le fichier n'a pas été corrompu (volontairement ou non d'ailleurs). On constate plusieurs fragilités dans ce processus : la page d'origine a pu être modifiée, et l'utilitaire de calcul peut être ''adapté'' pour fournir la signature attendue. C'est pourquoi il faut impérativement utiliser un utilitaire provenant d'une source de confiance. Il est aussi possible d'utiliser une [[Extension (logiciel)|extension]] pour le navigateur [[Mozilla Firefox]] comme ''{{lang|en|MD Hash tool}}''<ref>{{lien web|langue=en |url=http://mdhashtool.mozdev.org/installation.html |titre={{lang|en|mozdev.org - mdhashtool: installation}}<!-- Titre généré automatiquement -->}}.</ref> afin d'automatiser ce contrôle.

Vous pouvez également utiliser powershell natif : <blockquote><code>get-filehash -Algorithm MD5 -Path "c:\chemin vers le fichier"</code></blockquote><!-- 
Vous pouvez également utiliser un ''{{lang|en|shell}}'' pour l’''explorer'' de MS Windows, téléchargeable [http://www.frozenlogic.org/summerproperties.shtml ici]. Une fois installé, faites un clic droit sur votre fichier à vérifier puis propriété, regardez ensuite dans le 'nouvel onglet' appelé {{lang|en|checksums}}, c'est-à-dire vérificateur de somme algorithmique. D'ailleurs, le développeur Jonhny Mattsson a intégré deux vérificateurs de type CRC (16 et 32) et deux de type « ''{{lang|en|Digests}}'' » (MD5 et SHA-1).-->

== Cryptanalyse ==
{{article connexe|Cryptanalyse}}
À ses débuts, la fonction MD5 était considérée comme sûre, mais au cours du temps, des failles ont été découvertes dans son fonctionnement et durant l'été 2004, il a été cassé par des chercheurs chinois, [[Wang Xiaoyun|Xiaoyun Wang]], Dengguo Feng, [[Xuejia Lai]] (co-inventeur du célèbre algorithme de chiffrement [[International Data Encryption Algorithm|IDEA]]) et Hongbo Yu. Leur attaque a permis de découvrir une collision complète (deux messages différents qui produisent la même empreinte) sans passer par une méthode de type [[recherche exhaustive]]<ref name="pdf-collision">{{lien web|url=http://eprint.iacr.org/2004/264.pdf |titre={{lang|en|Musings on the Wang {{et al.}} MD5 Collision}} |format=pdf |langue=en}}.</ref>. 

Sur un système parallélisé, les calculs n'ont pris que quelques heures. Le MD5 n'est donc plus considéré comme sûr, mais l'algorithme développé par ces trois chercheurs concerne des collisions quelconques et ne permet pas de réaliser une collision sur une empreinte spécifique, c'est-à-dire réaliser un deuxième message, à partir de l'empreinte d'un premier message, qui produirait la même empreinte. Un projet de [[calcul distribué]] lancé en {{date||mars|2004|en informatique}}, {{Lien|MD5CRK}}, visait à découvrir une collision complète mais a été subitement arrêté après la découverte de l'équipe chinoise. La [[sécurité]] du MD5 n'étant plus garantie selon sa définition cryptographique, les spécialistes recommandent d'utiliser des fonctions de hachage plus récentes comme le [[SHA-256]].

On sait maintenant générer des collisions MD5 en moins d'une minute lorsque les deux blocs en collisions sont « libres »<ref>{{lien web|auteur=Vlastimil Klima |url=http://eprint.iacr.org/2006/105 |titre={{lang|en|Tunnels in Hash Functions: MD5 Collisions Within a Minute, Cryptology ePrint Archive {{nobr|Report 2006/105}}}} |date=17 avril 2006}}.</ref>. On peut aussi générer une infinité de collisions avec un texte T à partir de deux messages M1 et M2 de même longueur qui sont en collision. Il suffit de concaténer M1 et M2 avec T, tel que {{nobr|1=T1 = M1 + T}} et {{nobr|1=T2 = M2 + T}}, afin d'obtenir une collision complète entre T1 et T2. On ne peut toutefois pas générer une signature particulière et la falsification de documents reste un exercice difficile.

Dès [[2006 en informatique|2006]], il est par exemple possible de créer des pages [[Hypertext Markup Language|HTML]] aux contenus très différents et ayant pourtant le même MD5. La présence de [[Élément meta|métacodes]] de « bourrage » placés en commentaires, visibles seulement dans le source de la page web, trahit toutefois les pages modifiées pour usurper le MD5 d'une autre. La supercherie peut donc être levée si on examine les sources de la page en question.

En [[2008 en informatique|2008]], le logiciel [[BarsWF]]<ref>{{lien web|url=http://3.14.by/en/md5 |titre={{lang|en|World Fastest MD5 cracker BarsWF}} |langue=en}}.</ref> utilise les ressources des instructions [[Streaming SIMD Extension 2|SSE2]] et des processeurs massivement parallèles d'une carte graphique ([[Compute Unified Device Architecture|CUDA]]) pour casser du MD5 en force brute à la vitesse annoncée de {{nombre|350|millions}} de clés par seconde.

== Algorithme ==
[[Image:MD5 algorithm.svg|right|thumbnail|300px|Une opération de MD5. MD5 comprend {{nombre|64|blocs}} de ce type, groupés en quatre tours de {{nombre|16|opérations}}. ''F'' est une fonction non linéaire, qui varie selon le tour. ''M{{ind|i}}'' symbolise un bloc de {{unité|32|bits}} provenant du message à hacher et ''K{{ind|i}}'' est une constante de {{unité|32|bits}}, différentes pour chaque opération.]] 

=== Notation ===
*&nbsp;<nowiki>[<<<]</nowiki>{{ind|''s''}} est une [[Décalage circulaire|rotation]] de ''s'' bits vers la gauche, ''s'' varie pour chaque opération.
*&nbsp;<nowiki>[+]</nowiki> symbolise l'addition {{nobr|[[Modulo (informatique)|modulo]] 2{{exp|32}}}}.
*&nbsp;<math>\oplus, \wedge, \vee, \neg</math> symbolisent respectivement les opérations booléennes [[Fonction OU exclusif|XOR]], [[Fonction ET|AND]], [[Fonction OU|OR]] et [[Fonction NON|NOT]].

=== Préparation du message ===
MD5 travaille avec un message de taille variable et produit une empreinte de {{unité|128|bits}}. Le message est divisé en blocs de {{unité|512|bits}}, on applique un [[remplissage (cryptographie)|remplissage]] de manière à avoir un message dont la longueur est un multiple de 512. Le remplissage se présente comme suit : 

* on ajoute un ''1'' à la fin du message ;
* on ajoute une séquence de '0' (le nombre de zéros dépend de la longueur du remplissage nécessaire) ;
* on écrit la taille du message, un entier codé sur {{unité|64|bits}}.

Ce remplissage est toujours appliqué, même si la longueur du message peut être divisée par 512. Cette méthode de ''{{lang|en|padding}}'' est semblable à celle utilisée dans la plupart des algorithmes de ''[[Fonction de hachage cryptographique|message digest]]'' des familles MD (comme MD5 ou [[RIPEMD]]) ou SHA ([[SHA-1]] ou [[SHA-2|SHA-512]]) mais différente de celle de l'algorithme {{lang|en|[[Tiger (hash)|Tiger]]}} qui utilise une convention dite {{lang|en|[[Little endian]]}} d'ordonnancement des bits dans chaque octet.

La taille du message est codée en {{lang|en|[[Little endian]]}}. Le message a maintenant une taille en bits multiple de 512, c'est-à-dire qu'il contient un multiple de {{nombre|16|mots}} de {{unité|32|bits}}.

==== Constantes ====
MD5 utilise 64 valeurs constantes de mots de 32 bits, notés <math>K^{\{256\}}_0, K^{\{256\}}_1, ..., K^{\{256\}}_{63}~</math>. ces nombres représentent des sinus d'entiers. Les valeurs suivantes sont exprimées en notation hexadécimale (base 16).

Ils peuvent être obtenus avec la formule <math>K^{\{256\}}_i = \left\lfloor \left| 2^{32} \times \sin(i+1) \right|\right\rfloor
</math>.
{| class="wikitable" style="font-family:monospace;font-size:120%;line-height:normal"
!<math>K^{\{256\}}_{0}, ..., K^{\{256\}}_{7}</math>
|0xd76aa478
|0xe8c7b756
|0x242070db
|0xc1bdceee
|0xf57c0faf
|0x4787c62a
|0xa8304613
|0xfd469501
|-
!<math>K^{\{256\}}_{8}, ..., K^{\{256\}}_{15}</math>
|0x698098d8
|0x8b44f7af
|0xffff5bb1
|0x895cd7be
|0x6b901122
|0xfd987193
|0xa679438e
|0x49b40821
|-
!<math>K^{\{256\}}_{16}, ..., K^{\{256\}}_{23}</math>
|0xf61e2562
|0xc040b340
|0x265e5a51
|0xe9b6c7aa
|0xd62f105d
|0x02441453
|0xd8a1e681
|0xe7d3fbc8
|-
!<math>K^{\{256\}}_{24}, ..., K^{\{256\}}_{31}</math>
|0x21e1cde6
|0xc33707d6
|0xf4d50d87
|0x455a14ed
|0xa9e3e905
|0xfcefa3f8
|0x676f02d9
|0x8d2a4c8a
|-
!<math>K^{\{256\}}_{32}, ..., K^{\{256\}}_{39}</math>
|0xfffa3942
|0x8771f681
|0x6d9d6122
|0xfde5380c
|0xa4beea44
|0x4bdecfa9
|0xf6bb4b60
|0xbebfbc70
|-
!<math>K^{\{256\}}_{40}, ..., K^{\{256\}}_{47}</math>
|0x289b7ec6
|0xeaa127fa
|0xd4ef3085
|0x04881d05
|0xd9d4d039
|0xe6db99e5
|0x1fa27cf8
|0xc4ac5665
|-
!<math>K^{\{256\}}_{48}, ..., K^{\{256\}}_{55}</math>
|0xf4292244
|0x432aff97
|0xab9423a7
|0xfc93a039
|0x655b59c3
|0x8f0ccc92
|0xffeff47d
|0x85845dd1
|-
!<math>K^{\{256\}}_{56}, ..., K^{\{256\}}_{63}</math>
|0x6fa87e4f
|0xfe2ce6e0
|0xa3014314
|0x4e0811a1
|0xf7537e82
|0xbd3af235
|0x2ad7d2bb
|0xeb86d391
|}

=== Boucle principale ===
L'algorithme principal travaille avec un état sur {{unité|128|bits}}. Il est lui-même divisé en {{nombre|4|mots}} de {{unité|32|bits}} (en informatique, on utilise le terme "mot" pour désigner une valeur de 32 bits ou "word" en anglais) : ''A'', ''B'', ''C'' et ''D''. Ils sont initialisés au début avec des constantes. L'algorithme utilise ensuite les blocs provenant du message à hacher, ces blocs vont modifier l'état interne. Les opérations sur un bloc se décomposent en quatre rondes (étapes), elles-mêmes subdivisées en {{nombre|16|opérations}} similaires basées sur une fonction non linéaire ''F'' qui varie selon la ronde, une addition et une rotation vers la gauche. Les quatre fonctions non linéaires disponibles sont : 

* <math>F(B,C,D) = (B\wedge{C}) \vee (\neg{B} \wedge{D})</math> ;
* <math>G(B,C,D) = (B\wedge{D}) \vee (C \wedge \neg{D})</math> ;
* <math>H(B,C,D) = B \oplus C \oplus D</math> ;
* <math>I(B,C,D) = C \oplus (B \vee \neg{D})</math>.

<math>\oplus, \wedge, \vee, \neg</math> représente les opérateurs booléens [[XOR]], [[Fonction_ET|ET]], [[Fonction_OU|OU]] et [[Fonction_NON|NON]], respectivement.

== Pseudo-code ==
{{ancre|Pseudocode}}
MD5 peut s'écrire sous cette forme en [[pseudo-code]].

 //''Note : Toutes les variables sont sur {{nombre|32|bits}}''
 
 //''Définir r comme suit : ''
 '''var''' ''entier''[64] r, k
 r[ 0..15] := {7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22}
 r[16..31] := {5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20}
 r[32..47] := {4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23}
 r[48..63] := {6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21}
 
 //''MD5 utilise des sinus d'entiers pour ses constantes :''
 '''pour''' i '''de''' 0 '''à''' 63 '''faire'''
     k[i] := floor(abs(sin(i + 1)) × 2^32)
 '''fin pour'''
 
 //''Préparation des variables :''
 '''var''' ''entier'' h0 := 0x67452301
 '''var''' ''entier'' h1 := 0xEFCDAB89
 '''var''' ''entier'' h2 := 0x98BADCFE
 '''var''' ''entier'' h3 := 0x10325476
 
 //''Préparation du message (padding) :''
 '''ajouter''' le bit "1" '''au''' message
 '''ajouter''' le bit "0" '''jusqu'à ce que''' la taille du message en bits soit égale à 448 (mod 512)
 '''ajouter''' la taille du message initial en bits (avant le padding) '''codée''' en ''{{lang|en|64-bit little-endian}}'' '''au''' message
 
 //''Découpage en blocs de {{nombre|512|bits}} :''
 '''pour chaque''' ''bloc'' de '''{{nombre|512|bits}}''' du message
     subdiviser en {{nombre|16|mots}} de {{nombre|32|bits}} en {{lang|en|little-endian}} w[i], 0 ≤ i ≤ 15
 
     //''initialiser les valeurs de hachage :''
     '''var''' ''entier'' a := h0
     '''var''' ''entier'' b := h1
     '''var''' ''entier'' c := h2
     '''var''' ''entier'' d := h3
 
     //''Boucle principale :''
     '''pour''' i '''de''' 0 '''à''' 63 '''faire'''
         '''si''' 0 ≤ i ≤ 15 '''alors'''
               f := (b '''et''' c) '''ou''' (('''non''' b) '''et''' d)
               g := i
         '''sinon si''' 16 ≤ i ≤ 31 '''alors'''
               f := (d '''et''' b) '''ou''' (('''non''' d) '''et''' c)
               g := (5×i + 1) '''mod''' 16
         '''sinon si''' 32 ≤ i ≤ 47 '''alors'''
               f := b '''xor''' c '''xor''' d
               g := (3×i + 5) '''mod''' 16
         '''sinon si''' 48 ≤ i ≤ 63 '''alors'''
             f := c '''xor''' (b '''ou''' ('''non''' d))
             g := (7×i) '''mod''' 16
         '''fin si'''
         '''var''' ''entier'' temp := d
         d := c
         c := b
         b := '''leftrotate'''((a + f + k[i] + w[g]), r[i]) + b
         a := temp
     '''fin pour'''
 
     //''ajouter le résultat au bloc précédent :''
     h0 := h0 + a
     h1 := h1 + b 
     h2 := h2 + c
     h3 := h3 + d
 '''fin pour'''
 
 '''var''' ''entier'' empreinte := h0 '''concaténer''' h1 '''concaténer''' h2 '''concaténer''' h3 //''(en {{lang|en|little-endian}})''

<!--
=== Calcul de l'empreinte ===

'''Initialisation'''

On considère les registres A, B, C et D suivants :

* A = 0x67452301
* B = 0xefcdab89
* C = 0x98badcfe
* D = 0x10325476

Ainsi que les fonctions suivantes :

* F(x,y,z) = x and y or not(x) and z ⇒ (x & y) | (~x & z)
* G(x,y,z) = x and z or not(z) and y ⇒ (x & z) | (~z & y)
* H(x,y,z) = x xor y xor z ⇒ x ^ y ^ z
* I(x,y,z) = y xor (x or not(z)) ⇒ y ^ (x | ~z)

(la {{2e}} notation correspond au langage C)

* FF(a,b,c,d,k,s,i) ⇒ a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s)
* GG(a,b,c,d,k,s,i) ⇒ a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s)
* HH(a,b,c,d,k,s,i) ⇒ a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s)
* II(a,b,c,d,k,s,i) ⇒ a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s)

(<<< s représente une rotation circulaire à gauche de s bits)

Notez qu'il est souvent plus optimal d'utiliser les fonctions équivalentes :

* F(x,y,z) = ((z xor y) and x) xor z ⇒ ((z ^ y) & x) ^ z
* G(x,y,z) = ((y xor x) and z) xor y ⇒ ((y ^ x) & z) ^ y
* I(x,y,z) = ((z xor -1) or x) xor y ⇒ ((z ^ -1) | x) ^ y

Et le tableau T suivant :

* T[0] = 0xd76aa478
* T[1] = 0xe8c7b756
* T[2] = 0x242070db
* T[3] = 0xc1bdceee
* T[4] = 0xf57c0faf
* T[5] = 0x4787c62a
* T[6] = 0xa8304613
* T[7] = 0xfd469501
* T[8] = 0x698098d8
* T[9] = 0x8b44f7af
* T[10] = 0xffff5bb1
* T[11] = 0x895cd7be
* T[12] = 0x6b901122
* T[13] = 0xfd987193
* T[14] = 0xa679438e
* T[15] = 0x49b40821
* T[16] = 0xf61e2562
* T[17] = 0xc040b340
* T[18] = 0x265e5a51
* T[19] = 0xe9b6c7aa
* T[20] = 0xd62f105d
* T[21] = 0x02441453
* T[22] = 0xd8a1e681
* T[23] = 0xe7d3fbc8
* T[24] = 0x21e1cde6
* T[25] = 0xc33707d6
* T[26] = 0xf4d50d87
* T[27] = 0x455a14ed
* T[28] = 0xa9e3e905
* T[29] = 0xfcefa3f8
* T[30] = 0x676f02d9
* T[31] = 0x8d2a4c8a
* T[32] = 0xfffa3942
* T[33] = 0x8771f681
* T[34] = 0x6d9d6122
* T[35] = 0xfde5380c
* T[36] = 0xa4beea44
* T[37] = 0x4bdecfa9
* T[38] = 0xf6bb4b60
* T[39] = 0xbebfbc70
* T[40] = 0x289b7ec6
* T[41] = 0xeaa127fa
* T[42] = 0xd4ef3085
* T[43] = 0x04881d05
* T[44] = 0xd9d4d039
* T[45] = 0xe6db99e5
* T[46] = 0x1fa27cf8
* T[47] = 0xc4ac5665
* T[48] = 0xf4292244
* T[49] = 0x432aff97
* T[50] = 0xab9423a7
* T[51] = 0xfc93a039
* T[52] = 0x655b59c3
* T[53] = 0x8f0ccc92
* T[54] = 0xffeff47d
* T[55] = 0x85845dd1
* T[56] = 0x6fa87e4f
* T[57] = 0xfe2ce6e0
* T[58] = 0xa3014314
* T[59] = 0x4e0811a1
* T[60] = 0xf7537e82
* T[61] = 0xbd3af235
* T[62] = 0x2ad7d2bb
* T[63] = 0xeb86d391

M représente le message (message original + {{lang|en|padding}} + longueur du message original). M[n-1] représente le n-ième mot de {{unité|32|bits}} du message.
<br />N est le nombre de mots de {{unité|32|bits}}.
<br />X est un tableau de {{nombre|16|mots}} de {{unité|32|bits}}.
<br />AA, BB, CC et DD sont des registres tampons.

'''Calcul'''

Voici le pseudo-code correspondant aux calculs à effectuer :

  Boucle i de 0 à N/16 - 1
  Faire
    Boucle j de 0 à 15
    Faire
      X[j] = M[i*16 + j]
    <nowiki>FinBoucle</nowiki> j
    AA = A
    BB = B
    CC = C
    DD = D
    
    /* Ronde 1 */
    FF(A, B, C, D, 0, 7, 0)
    FF(D, A, B, C, 1, 12, 1)
    FF(C, D, A, B, 2, 17, 2)
    FF(B, C, D, A, 3, 22, 3)
    FF(A, B, C, D, 4, 7, 4)
    FF(D, A, B, C, 5, 12, 5)
    FF(C, D, A, B, 6, 17, 6)
    FF(B, C, D, A, 7, 22, 7)
    FF(A, B, C, D, 8, 7, 8)
    FF(D, A, B, C, 9, 12, 9)
    FF(C, D, A, B, 10, 17, 10)
    FF(B, C, D, A, 11, 22, 11)
    FF(A, B, C, D, 12, 7, 12)
    FF(D, A, B, C, 13, 12, 13)
    FF(C, D, A, B, 14, 17, 14)
    FF(B, C, D, A, 15, 22, 15)
    
    /* Ronde 2 */
    GG(A, B, C, D, 1, 5, 16)
    GG(D, A, B, C, 6, 9, 17)
    GG(C, D, A, B, 11, 14, 18)
    GG(B, C, D, A, 0, 20, 19)
    GG(A, B, C, D, 5, 5, 20)
    GG(D, A, B, C, 10, 9, 21)
    GG(C, D, A, B, 15, 14, 22)
    GG(B, C, D, A, 4, 20, 23)
    GG(A, B, C, D, 9, 5, 24)
    GG(D, A, B, C, 14, 9, 25)
    GG(C, D, A, B, 3, 14, 26)
    GG(B, C, D, A, 8, 20, 27)
    GG(A, B, C, D, 13, 5, 28)
    GG(D, A, B, C, 2, 9, 29)
    GG(C, D, A, B, 7, 14, 30)
    GG(B, C, D, A, 12, 20, 31)
    
    /* Ronde 3 */
    HH(A, B, C, D, 5, 4, 32)
    HH(D, A, B, C, 8, 11, 33)
    HH(C, D, A, B, 11, 16, 34)
    HH(B, C, D, A, 14, 23, 35)
    HH(A, B, C, D, 1, 4, 36)
    HH(D, A, B, C, 4, 11, 37)
    HH(C, D, A, B, 7, 16, 38)
    HH(B, C, D, A, 10, 23, 39)
    HH(A, B, C, D, 13, 4, 40)
    HH(D, A, B, C, 0, 11, 41)
    HH(C, D, A, B, 3, 16, 42)
    HH(B, C, D, A, 6, 23, 43)
    HH(A, B, C, D, 9, 4, 44)
    HH(D, A, B, C, 12, 11, 45)
    HH(C, D, A, B, 15, 16, 46)
    HH(B, C, D, A, 2, 23, 47)
    
    /* Ronde 4 */
    II(A, B, C, D, 0, 6, 48)
    II(D, A, B, C, 7, 10, 49)
    II(C, D, A, B, 14, 15, 50)
    II(B, C, D, A, 5, 21, 51)
    II(A, B, C, D, 12, 6, 52)
    II(D, A, B, C, 3, 10, 53)
    II(C, D, A, B, 10, 15, 54)
    II(B, C, D, A, 1, 21, 55)
    II(A, B, C, D, 8, 6, 56)
    II(D, A, B, C, 15, 10, 57)
    II(C, D, A, B, 6, 15, 58)
    II(B, C, D, A, 13, 21, 59)
    II(A, B, C, D, 4, 6, 60)
    II(D, A, B, C, 11, 10, 61)
    II(C, D, A, B, 2, 15, 62)
    II(B, C, D, A, 9, 21, 63)
    
    A = A + AA
    B = B + BB
    C = C + CC
    D = D + DD
  <nowiki>FinBoucle</nowiki> i

'''Résultats'''

Le résultat correspond aux registres A, B, C, D concaténés de l'octet de poids faible de A à l'octet de poids fort de D.

C'est-à-dire :
<br />({{lang|en|Digest}} est une chaîne de {{nombre|16|caractères}}, Digest[n-1] est le n-ième caractère, le {{1er}} octet est l'octet de poids faible, …, le {{4e}} est l'octet de poids fort)

Digest[0] = {{1er}} octet de A
<br />Digest[1] = {{2e}} octet de A
<br />Digest[2] = {{3e}} octet de A
<br />Digest[3] = {{4e}} octet de A
<br />Digest[4] = {{1er}} octet de B
<br />Digest[5] = {{2e}} octet de B
<br />Digest[6] = {{3e}} octet de B
<br />Digest[7] = {{4e}} octet de B
<br />Digest[8] = {{1er}} octet de C
<br />Digest[9] = {{2e}} octet de C
<br />Digest[10] = {{3e}} octet de C
<br />Digest[11] = {{4e}} octet de C
<br />Digest[12] = {{1er}} octet de D
<br />Digest[13] = {{2e}} octet de D
<br />Digest[14] = {{3e}} octet de D
<br />Digest[15] = {{4e}} octet de D

L'empreinte de M est Digest.

-->

== Notes et références ==
{{Références|colonnes=}}

== Annexes ==
=== Articles connexes ===
* [[Résistance aux collisions]]
* [[md5sum]]

=== Liens externes ===
* {{lien web|url=http://www.ietf.org/rfc/rfc1321.txt |titre={{nobr|RFC 1321}} qui détaille l'algorithme |langue=en}}<!-- pas sûr que l’usage du modèle lien web soit adapté dans ce cas-ci ! (ce n’est pas le réel titre de la page liée) -->
* {{lien web|url=http://www.authsecu.com/decrypter-dechiffrer-cracker-hash-md5/decrypter-dechiffrer-cracker-hash-md5.php |titre=Fonction de décryptage MD5}}
* {{lien web|url=http://eprint.iacr.org/2004/356 |langue=en |titre={{lang|en|Practical Attacks on Digital Signatures Using MD5 Message Digest}} |auteur=Ondrej Mikle}}
* {{lien web|url=http://cryptography.hyperlink.cz/md5/MD5_collisions.pdf |langue=en |titre={{lang|en|Finding MD5 collisions - A toy for notebook}} |format=pdf |auteur=Vlastimil Klíma}}
* {{lien web|url=http://eprint.iacr.org/2004/264.pdf |langue=en |titre={{lang|en|Musings on the Wang {{et al.}} - MD5 Collision}} |format=pdf |auteur=P. Hawkes {{et al.}}}}
* {{lien web|url=https://codebeautify.org/md5-hash-generator |langue=en |titre={{lang|en|Générateur de Hash MD5 - MD5 HASH Generator}} }}

{{Palette|Fonctions de hachage cryptographiques}}
{{Portail|cryptologie|sécurité informatique}}

[[Catégorie:Algorithme de hachage]]