Générateur MD5

MD5 (Message-Digest Algorithm 5) est une fonction de hachage cryptographique largement utilisée qui produit une valeur de hachage de 128 bits (16 octets), généralement exprimée sous forme d'un nombre hexadécimal à 32 chiffres. Il a été conçu par Ronald Rivest en 1991 pour remplacer l'algorithme MD4 antérieur et a été spécifié dans le RFC 1321 en avril 1992.

Malgré ses vulnérabilités de sécurité, MD5 est encore couramment utilisé pour des applications non sécuritaires telles que les sommes de contrôle pour vérifier l'intégrité des données et détecter les corruptions involontaires. Il reste adapté à d'autres fins non cryptographiques en raison de ses exigences de calcul inférieures par rapport aux algorithmes de hachage sécurisés plus récents.

MD5 a été conçu par le professeur Ronald Rivest du MIT comme un remplacement plus sûr pour MD4. L'algorithme prend un message d'entrée de longueur arbitraire et produit une "empreinte digitale" ou "condensé de message" de 128 bits comme sortie. L'algorithme MD5 est conçu pour être assez rapide sur des machines 32 bits et ne nécessite pas de grandes tables de substitution, permettant une implémentation compacte.

L'algorithme traite un message de longueur variable en une sortie de longueur fixe de 128 bits en décomposant l'entrée en blocs de 512 bits. Il opère sur un état de 128 bits divisé en quatre mots de 32 bits (A, B, C et D) et passe par quatre séries d'opérations, chaque tour effectuant 16 opérations basées sur des fonctions non linéaires, une addition modulaire et une rotation de bits.

// Initialisation des variables
A = 0x67452301
B = 0xEFCDAB89
C = 0x98BADCFE
D = 0x10325476

// Préparation des fonctions
F(X,Y,Z) = (X ET Y) OU ((NON X) ET Z)
G(X,Y,Z) = (X ET Z) OU (Y ET (NON Z))
H(X,Y,Z) = X XOR Y XOR Z
I(X,Y,Z) = Y XOR (X OU (NON Z))

// Traitement du message (le message doit être un multiple de 512 bits)
// Remplir le message jusqu'à ce que sa longueur ≡ 448 (mod 512)
// Ajouter la représentation sur 64 bits de la longueur originale du message

// Boucle principale
pour chaque bloc de 512 bits du message rempli:
    // Décomposer le bloc en seize mots de 32 bits (M[0..15])
    // Copier l'état du bloc
    AA = A
    BB = B
    CC = C
    DD = D
    
    // Tour 1
    pour i de 0 à 15:
        A = B + ((A + F(B,C,D) + M[i] + T[i]) <<< s[i])
        Rotation de A, B, C, D
    
    // Tour 2
    pour i de 16 à 31:
        A = B + ((A + G(B,C,D) + M[(5*i + 1) mod 16] + T[i]) <<< s[i])
        Rotation de A, B, C, D
    
    // Tour 3
    pour i de 32 à 47:
        A = B + ((A + H(B,C,D) + M[(3*i + 5) mod 16] + T[i]) <<< s[i])
        Rotation de A, B, C, D
    
    // Tour 4
    pour i de 48 à 63:
        A = B + ((A + I(B,C,D) + M[(7*i) mod 16] + T[i]) <<< s[i])
        Rotation de A, B, C, D
    
    // Ajouter le résultat du traitement du bloc
    A = A + AA
    B = B + BB
    C = C + CC
    D = D + DD

// Sortie
MD5 = A || B || C || D // Concaténé pour obtenir un résultat de 128 bits

En 1996, une faille a été découverte dans la conception de MD5, bien qu'elle n'ait pas été considérée comme fatale à l'époque. D'ici 2004, des vulnérabilités plus graves ont été découvertes, et des chercheurs ont démontré des attaques pratiques par collision - des méthodes pour créer des paires d'entrées différentes qui produisent la même valeur de hachage MD5.

En 2008, un groupe de chercheurs a utilisé ces vulnérabilités pour créer un certificat SSL contrefait qui semblait légitime. Le logiciel malveillant Flame a exploité les faiblesses de MD5 pour falsifier une signature numérique Microsoft en 2012. Les attaques par collision modernes peuvent trouver des collisions MD5 en quelques secondes sur du matériel informatique standard.