L'algorithme MD5 (avec exemples)

Cet article couvre en détail les mécanismes de l'algorithme MD5. Il s'agit de notre deuxième et dernier article sur la fonction de hachage MD5, qui est un algorithme plus ancien et non sécurisé qui transforme des données de longueurs aléatoires en hachages fixes de 128 bits. Notre Qu’est-ce que MD5 ? concentré sur les MD5 :

• Arrière-plan
• Histoire
• Applications
• Problèmes de sécurité

Cette fois, nous nous concentrerons sur ce qui se passe réellement lorsque les données passent par l’algorithme de hachage MD5. Comment quelque chose comme « Ils sont déterministes » (c'est juste une phrase aléatoire que nous avons utilisée dans l'autre article) peut-il être obtenu ? transformé en un hachage de 128 bits comme celui-ci ?

23db6982caef9e9152f1a5b2589e6ca3

Comment fonctionne l'algorithme MD5 ?

Montrons comment fonctionne l'algorithme MD5 à travers un exemple. Notre entrée, « Ils sont déterministes », devient extrêmement différente lorsqu'elle est soumise à la fonction de hachage MD5. Tout ce que nous pouvons garantir, c'est qu'il aura une longueur de 128 bits, ce qui équivaut à 32 caractères. Mais comment l’algorithme MD5 peut-il prendre des entrées de n’importe quelle longueur et les transformer en chaînes apparemment aléatoires de longueur fixe ?

Conversion les données en binaire

Lorsque nous mettons « Ils sont déterministes » dans une fonction de hachage MD5, la première chose qui se produit est qu'elle est convertie en binaire. Cela se fait selon le Code standard américain pour l'échange d'informations (ASCII) , qui est essentiellement un norme que nous utilisons pour convertir un texte lisible par l'homme en code binaire que les ordinateurs peuvent lire .

Utiliser un tableau ASCII, nous voyons qu'une lettre majuscule « T » s'écrit « 01010100 » en binaire. Un « h » minuscule est « 01101000 », un « e » minuscule est « 01100101 » et un « y » minuscule est « 01111001 ». Le code binaire d'un espace (SP) est « 00100000 ». Vous pouvez le voir dans le tableau en haut de la deuxième colonne, en ligne avec le nombre décimal 32.

Si nous continuons de cette manière, nous voyons que notre entrée « Ils sont déterministes » s'écrit en binaire comme :

01010100 01101000 01100101 01111001 00100000 01100001 01110010 01100101 00100000 01100100 01100101 01110100 01100101 0111 0010 01101101 01101001 01101110 01101001 0110011 01110100 01101001 011001

Rembourrage dans l'algorithme MD5

La prochaine étape dans MD5 est de ajouter rembourrage . Les entrées dans MD5 sont divisées en blocs de 512 bits, avec un remplissage ajouté pour remplir le reste de l'espace du bloc. . Notre entrée comporte 22 caractères, espaces compris, et chaque caractère comporte 8 bits. Cela signifie que l'entrée totalise 176 bits. Avec une entrée de seulement 176 bits et un bloc de 512 bits à remplir, nous avons besoin de 336 bits de remplissage pour terminer le bloc.

Le schéma de remplissage de MD5 semble assez étrange. Après avoir disposé les 176 bits initiaux du binaire qui représentent notre entrée, le reste du bloc est complété par un seul, puis suffisamment de zéros pour l'amener à une longueur de 448 bits. Donc:

448 – 1 – 176 = 271

Donc le remplissage de ce bloc comprendra un un, puis 271 zéros supplémentaires . La raison pour laquelle nous n'avons besoin que de le compléter jusqu'à 448 bits (au lieu de 512) est que les 64 derniers bits (512 – 64 = 448) sont réservés pour afficher la longueur du message en binaire. Dans ce cas, le nombre 176 est 10110000 en binaire . Cela constitue la toute fin du schéma de remplissage, tandis que les 56 bits précédents (64 moins les huit bits qui composent 10110000) sont tous remplis de zéros.

Dans les cas où la longueur du message occupe un plus grand nombre de bits, il y aura moins de zéros. Si la longueur de l'entrée initiale est supérieure à 64 bits (si elle est supérieure à 264, ce qui équivaut à 18 446 744 073 709 551 616 en décimal), alors seuls les 64 bits de poids faible sont utilisés.

Le terme « bits les moins significatifs » désigne essentiellement les nombres les plus à droite. A titre d'exemple, si nous voulions uniquement les quatre bits les moins significatifs d'un nombre binaire aléatoire comme 0101 1110 , nous ferions référence au 1110 et sans tenir compte du 0101 initial.

Une fois le schéma de remplissage terminé, nous nous retrouvons avec la chaîne de 512 bits suivante :

01010100 01101000 01100101 01111001 00100000 01100001 01110010 01100101 00100000 01100100 01100101 01110100 01100101 0111 0010 01101101 01101001 01101110 01101001 0110011 01110100 01101001 011001 10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 0000 0000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 0 0000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 10110000

Les 176 premiers bits (la longueur varie en fonction de l'entrée initiale) représentent notre entrée initiale de « Ils sont déterministes » en binaire. Les 272 bits suivants sont un un suivi de 271 zéros. Les 64 derniers bits correspondent à la longueur de notre entrée initiale (176 bits), écrite en binaire. Il est précédé de zéros pour remplir le reste des 64 bits. Les trois composants de l'entrée complétée ont été divisés entre texte gras et texte normal pour permettre de voir plus facilement où chacun commence et se termine.

Entrées supérieures à 512 bits

Lorsque l’entrée initiale fait plus de 448 bits, elle est divisée en plusieurs blocs de 512 bits. Chaque bloc comprend 512 bits de données d'entrée jusqu'à ce que l'intégralité de l'entrée soit divisée en blocs. Le bloc final doit inclure au moins 1 bit de remplissage, plus la longueur de 64 bits en binaire.

Dans le cas où les données d'entrée restantes font exactement 448 bits,un bloc supplémentaire entier devrait être ajouté pour le remplissage. L'avant-dernier bloc comprendrait les 448 derniers bits de données, puis un un, suivi de 63 zéros pour remplir le bloc. Le bloc final comprendrait 448 zéros (soit un total de 512 bits de remplissage), suivis de la longueur du message de 64 bits en binaire.

S’il restait 449 bits de données d’entrée, il faudrait quand même ajouter un bloc supplémentaire. L'avant-dernier bloc comprendrait les 449 bits des données d'entrée restantes, suivis d'un un et de 62 zéros pour remplir le bloc. Le bloc final contiendrait 448 zéros, suivis de la longueur du message de 64 bits.

En revanche, si les données restantes ne faisaient que 447 bits, le bloc final inclurait les 447 derniers bits de données d'entrée, suivis d'un seul comme remplissage, sans aucun zéro. La longueur du message de 64 bits serait ajoutée à la fin pour porter le total à 512 bits.

La différence entre ces deux cas peut paraître étrange, mais elle permet de compléter l'entrée d'au moins un chiffre, tout en laissant de la place pour la longueur du message de 64 bits.

L'algorithme principal MD5

Voici le principal algorithme MD5 dans toute sa splendeur :

Vous ne comprenez pas ce qui se passe ? C'est très bien. C’est un algorithme compliqué, donc il n’y a pas vraiment moyen de le dessiner sans que cela prête à confusion.

L'entrée M

En haut, nous avons notre contribution, qui dit Bloc de message de 512 bits, M . À ce stade du diagramme, il inclut déjà tout le remplissage que nous avons ajouté à la dernière étape. Si vous suivez la flèche vers le bas, vous verrez qu'elle entre dans chacun des quatre rectangles « 16 opérations de… ». Chacun de ces quatre rectangles est appelé rond , et chacun d'eux est composé d'une série de seize opérations

Cela signifie que notre entrée, M, est une entrée dans chacune de ces quatre étapes . Cependant, avant de pouvoir l'utiliser comme entrée, notre M de 512 bits doit être divisé en seize « mots » de 32 bits. Chacun de ces mots se voit attribuer son propre numéro, allant de M0 à M15. Dans notre exemple, ces 16 mots sont :

• M.₀– 01010100 01101000 01100101 01111001
• M.₁– 00100000 01100001 01110010 01100101
• M._deux– 00100000 01100100 01100101 01110100
• M.₃– 01100101 01110010 01101101 01101001
• M.₄– 01101110 01101001 01110011 01110100
• M.₅– 01101001 01100011 10000000 00000000
• M.₆– 00000000 00000000 00000000 00000000
• M.₇– 00000000 00000000 00000000 00000000
• M.₈– 00000000 00000000 00000000 00000000
• M.₉– 00000000 00000000 00000000 00000000
• M._dix– 00000000 00000000 00000000 00000000
• M._onze– 00000000 00000000 00000000 00000000
• M.₁₂– 00000000 00000000 00000000 00000000
• M.₁₃– 00000000 00000000 00000000 00000000
• M.₁₄– 00000000 00000000 00000000 00000000
• M._quinze– 00000000 00000000 00000000 10110000

Nous utiliserons principalement l'hexadécimal pour le reste de l'article. Si vous ne comprenez pas clairement ce qu'est l'hexadécimal, reportez-vous à cette section de notre article précédent sur MD5. Utiliser un convertisseur en ligne , les équivalents hexadécimaux de nos nombres binaires sont :

• M.₀– 54686579
• M.₁– 20617265
• M._deux– 20646574
• M.₃-65726D69
• M.₄-6E697374
• M.₅– 69638000
• M.₆– 00000000
• M.₇– 00000000
• M.₈– 00000000
• M.₉– 00000000
• M._dix– 00000000
• M._onze– 00000000
• M.₁₂– 00000000
• M.₁₃– 00000000
• M.₁₄– 00000000
• M._quinze– 000000B0

Chacune de ces seize valeurs agit comme entrée dans l'ensemble complexe d'opérations qui sont représentées par chaque rectangle « 16 opérations de… ». Encore une fois, ces quatre rectangles « 16 opérations de… » représentent les quatre tours différents, celui du haut représentant le premier tour, tandis que celui du bas est le quatrième tour. . Bien que chacune de ces entrées M soit utilisée à chaque tour, elles sont ajoutées dans des ordres différents.

Au premier tour, les M entrées sont ajoutées séquentiellement dans l'algorithme, par ex. M0, M1, M2… M15.

Au deuxième tour, les entrées M sont ajoutées dans l'ordre suivant :

M1, M6, M11, M0, M5, M10, M15, M4, M9, M14, M3, M8, M13, M2, M7, M12

Au troisième tour, les M entrées sont ajoutées dans cet ordre :

M5, M8, M11, M14, M1, M4, M7, M10, M13, M0, M3, M6, M9, M12, M15, M2

Au quatrième tour, les entrées M sont ajoutées dans l'ordre suivant :

M0, M7, M14, M5, M12, M3, M10, M1, M8, M15, M6, M13, M4, M11, M2, M9

Dans les cas où l'entrée initiale et son remplissage sont supérieurs à un bloc de 512 bits, le schéma de numérotation est réinitialisé. Une fois le premier bloc de données traité, les entrées du deuxième bloc sont également étiquetées de M0 à M15.

Pour plus de simplicité, notre exemple s'en tiendra à un seul bloc de données de 512 bits contenant 16 mots.

Les vecteurs d'initialisation de l'algorithme MD5

Maintenant que nous avons un peu expliqué nos entrées M, il est temps de porter notre attention sur le Vecteurs d'initialisation , qui sont affichés juste en dessous du Bloc de message de 512 bits, M dans le diagramme.

Au début, les vecteurs d'initialisation sont quatre nombres distincts, spécifiés dans le RFC qui décrit la norme MD5. Ceux-ci sont:

• A – 01234567
• B – 89abcdef
• C-fedcba98
• D-76543210

Au fur et à mesure que nous progressons dans l'algorithme, ces nombres seront remplacés par divers résultats que nous produisons grâce aux calculs. Cependant, ces quatre vecteurs d’initialisation sont importants pour démarrer. Tous les quatre sont des entrées dans le premier rectangle des « 16 opérations de… ».

Les fonctions MD5 F, G, H et I

La première étape du rectangle des « 16 opérations de… » est la fonction :

F(B, C, D) = (B∧C)∨(¬B∧D)

Cela semble déroutant ? Nous l'expliquerons en profondeur plus tard. La chose importante à noter est que les vecteurs d'initialisation B, C et D sont utilisés dans cette fonction comme entrées.

Dans les dernières étapes de l'algorithme, les valeurs qui remplacent les vecteurs d'initialisation B, C et D rempliront leur rôle.

La fonction F(B, C, D) est utilisée pour les 16 opérations du premier tour. Dans les tours suivants, sa place est prise par ces fonctions :

Tour 2 : G(B, C, D) = (B∧D)∨(C∧¬D)

Tour 3 : H(B, C, D) =B⊕C⊕D

Tour 4 : I(B, C, D) = C⊕(B∨¬D)

Ne vous inquiétez pas, nous vous les expliquerons également.

Les opérations

Ce diagramme donne un aperçu approximatif de ce qui se passe dans chaque rectangle des « 16 opérations de… » :

Lorsque nous zoomons sur chaque rectangle des « 16 opérations de… », vous pouvez voir que les flèches de B, C et D pointent vers une case intitulée F. Cela représente la fonction F(B, C, D) – notez que dans l’autre trois tours, la fonction F est remplacée par les fonctions G, H et I, respectivement.

Si vous suivez la flèche dans la case suivante, cela indique que la sortie de F(B, C, D) est ajoutée au vecteur d'initialisation A , avec un type spécial d'ajout. Dans la première opération, la valeur du vecteur d’initialisation A est 01234567, mais elle change lors des opérations suivantes.

Le résultat passe à la case suivante, où il est ajouté à une partie de l'entrée, représentée par Mi. Après cela, une constante K est ajoutée au résultat, en utilisant le même type spécial d’addition. Les valeurs de K sont dérivées de la formule :

abs(péché(i+ 1))×2³²

Cette formule n’est pas trop importante pour comprendre le reste de MD5. Cependant, nous avons besoin des valeurs auxquelles cela conduit, qui sont :

• K1-D76AA478
• K2-E8C7B756
• K3 – 242070DB
• K4 – C1BDCEEE
• K5 - F57COFA
• K6-4787C62A
• K7-A8304613
• K8-FD469501
• K9-698098D8
• K10-8B44F7AF
• K11 – FFFF5BB1
• K12-895CD7BE
• K13-6B901122
• K14-FD987193
• K15-A679438E
• K16-49B40821
• K17-F61E2562
• K18-C040B340
• K19-265E5A51
• K20-E9B6C7AA
• K21-D62F105D
• K22 - 02441453
• K23-D8A1E681
• K24-E7D3FBC8
• K25-21E1CDE6
• K26-C33707D6
• K27-F4D50D87
• K28-455A14ED
• K29-A9E3E905
• K30 - FCEFA3F8
• K31-676F02D9
• K32-8D2A4C8A
• K33 - FFFA3942
• K34-8771F681
• K35-699D6122
• K36-FDE5380C
• K37-A4BEEA44
• K38-4BDECFA9
• K39-F6BB4B60
• K40 – BEBFBC70
• K41-289B7EC6
• K42-EAA127FA
• K43-D4EF3085
• K44-04881D05
• K45-D9D4D039
• K46-E6DB99E5
• K47-1FA27CF8
• K48-C4AC5665
• K49-F4292244
• K50-432AFF97
• K51-AB9423A7
• K52-FC93A039
• K53-655B59C3
• K54 – 8F0CCC92
• K55 – FFEFF47D
• K56-85845DD1
• K57-6FA87E4F
• K58 – FE2CE6E0
• K59-A3014314
• K60-4E0811A1
• K61-F7537E82
• K62-BD3AF235
• K63-2AD7D2BB
• K64-EB86D391

Une de ces valeurs K est utilisée dans chacune des 64 opérations pour un bloc de 512 bits. K1 à K16 sont utilisés au premier tour, K17 à K32 sont utilisés au deuxième tour, K33 à K48 sont utilisés au troisième tour et K49 à K64 sont utilisés au quatrième tour.

Une fois la valeur K ajoutée, l’étape suivante consiste à décaler le nombre de bits vers la gauche d’une quantité prédéfinie, Si. Nous expliquerons comment cela fonctionne plus loin dans l'article. La quantité de décalage de chaque bit varie en fonction de l'opération effectuée par l'algorithme MD5. Chaque opération a un nombre prédéfini d'équipes et les opérations les utilisent dans un ordre séquentiel (par exemple S1, S2, S3, etc.). Les valeurs S sont :

• Premier tour
  • S1, S5, S9, S13 – 7
  • S2, S6, S10, S14 – 12
  • S3, S7, S11, S15-17
  • S4, S8, S12, S16, – 22

• Deuxième round
  • S17, S21, S25, S29-5
  • S18, S22, S26, S30 – 9
  • S19, S23, S27, S31-14
  • S20, S24, S28, S32 – 20

• Troisième tour
  • S33, S37, S41, S45-4
  • S34, S38, S42, S46-11
  • S35, S39, S43, S47-16
  • S36, S40, S44, S48 – 13

• Quatrième tour
  • S49, S53, S57, S61-6
  • S50, S54, S58, S62-10
  • S51, S55, S59, S63-15
  • S52, S56, S60, S64-21

Une fois le décalage effectué, le résultat de tous ces calculs est ajouté à la valeur du vecteur d'initialisation B. Initialement, c'est 89abcdef, mais cela change lors des opérations ultérieures.

La sortie de cette valeur devient le vecteur d’initialisation de B lors de l’opération suivante. Les vecteurs d'initialisation B, C et D sont mélangés sur un espace vers la droite, de sorte que B devient C, C devient D et D devient A lors de l'opération suivante.

Quatre séries de 16 opérations

Ce processus se déroule en boucle pendant 16 opérations. A chaque fois, les entrées stipulées ci-dessus sont utilisées pour leur fonctionnement respectif. La 17ème opération marque le début du deuxième tour, et le processus continue de la même manière, sauf que la fonction G est utilisée à la place.

Les choses changent à nouveau dès la 33ème opération, lorsque la fonction H est utilisée pendant toute la durée du troisième tour. Le quatrième tour commence à la 49ème opération et la fonction I est utilisée à la place.

À la fin du quatrième tour et de sa 64ème opération, les sorties sont ajoutées aux vecteurs d'initialisation d'origine que nous avons répertoriés ci-dessus. Le résultat de ce calcul est le hachage MD5 final de notre entrée.

Confus?

Ce n’est pas grave, nous avons commencé par un aperçu approximatif et simpliste qui vise uniquement à vous donner un aperçu des nombreuses étapes impliquées dans MD5. Dans la section suivante, nous examinerons chaque étape du processus plus en détail.

L'algorithme MD5 en profondeur

Commençons par approfondir la fonction F.

La fonction F

La fonction F est une opération au niveau du bit (les fonctions G, H et I le sont aussi). Il s’agit essentiellement de moyens rapides et simples permettant aux ordinateurs d’effectuer des opérations arithmétiques avec le binaire. Alors que les ordinateurs font leur travail en binaire, nous nous en tiendrons principalement à l’hexadécimal car il est plus facile à lire. Faire référence à la section sur l'hexadécimal dans notre autre article sur MD5 si vous avez besoin d’une compréhension plus approfondie de ce que c’est.

La fonction F est :

F(B, C, D) = (B∧C)∨(¬B∧D)

Si vous n'avez jamais étudié Algèbre de Boole auparavant, ces symboles pouvaient prêter à confusion. Une discussion approfondie de l’algèbre booléenne nous amènerait trop loin, mais il s’agit fondamentalement d’un type particulier d’algèbre qui est largement utilisé en informatique.

Les symboles que vous devrez connaître sont les suivants :

• ∧– ET
• ∨– OU
• ¬ – PAS
• ⊕ – XOR, ce qui signifie essentiellement l'un ou l'autre, mais pas les deux.

Nous pouvons maintenant intégrer les nombres de nos vecteurs d'initialisation dont nous avons parlé dans le Vecteurs d'initialisation section:

F (89abcdef, fedcba98, 76543210) = (89abcdef ET fedcba98) OU (NON-89abcdef ET 76543210)

On peut compléter ce calcul par un calculateur booléen en ligne . Cependant, nous devrons le diviser en étapes distinctes car cette calculatrice ne nous permet pas d’utiliser des parenthèses pour ordonner correctement l’équation.

Si vous voulez l'essayer par vous-même :

• Entrer 89abcdef dans l’entrée A.
• Sélectionner ET dans le menu déroulant en dessous.
• Entrer fedcba98 dans l’entrée B.
• Sélectionner Hex à partir des quatre systèmes numériques différents. Il est situé juste en dessous du résultat de l’opération.

La réponse apparaît à côté du résultat de l'opération :

88888888

Passons maintenant à l’autre moitié de l’équation :

• Sélectionner PAS à gauche de l’entrée A.
• Entrer 89abcdef dans l’entrée A.
• Sélectionner ET dans le menu déroulant en dessous.
• Entrer 76543210 dans l’entrée B.
• Sélectionner Hex à partir des quatre systèmes numériques différents, situés juste en dessous du résultat de l'opération.

Notre réponse est :

76543210

Nous avons résolu une partie de l’équation, nous savons donc maintenant que :

F(B, C, D) = 88888888 OU 76543210

Nous pouvons le terminer par :

• Entrer 88888888 dans l’entrée A (assurez-vous que la case NOT n’est plus sélectionnée).
• Sélection OU dans le menu déroulant en dessous.
• Entrer 76543210 dans l’entrée B.
• Sélection Hex à partir des quatre systèmes numériques différents, situés juste en dessous du résultat de l'opération.

Si vous l’avez bien fait, le résultat de F(B, C, D) devrait être :

fedcba98

L'algèbre booléenne fonctionne différemment de l'algèbre normale. Si vous êtes confus par l'ensemble du processus, vous devrez peut-être faire une étude de base sur la page d'algèbre booléenne que nous avons liée ci-dessus. Sinon, vous n’aurez qu’à nous faire confiance.

Jusqu’à présent, nous avons seulement effectué notre premier calcul. Jetez un œil au schéma pour voir où nous allons :

Tout ce que nous avons fait, c'est exécuter les valeurs B, C et D via la fonction F. Il y a bien plus à faire dans ce diagramme. Ce diagramme ne représente qu'une seule opération , et il y en a seize dans un tour. Il y a quatre tours pour chaque bloc de 512 bits, nous donnant un total de 64 opérations . S'il existe plus d'un bloc de données d'entrée de 512 bits, chaque bloc doit subir ces 64 opérations. Nous avons beaucoup de choses à surmonter, alors allons de l’avant.

Ajout modulaire

Si vous regardez la flèche sortant de la case F, vous verrez qu’elle pointe vers un autre carré qui ressemble un peu à une fenêtre. Il y a aussi une flèche du A entrant dans cette case. Le symbole de la boîte représente ajout modulaire .

Nous avons introduit des opérations modulaires dans notre autre article sur MD5 . Vous pouvez revoir cette section si vous avez besoin d’un rappel rapide. Cependant, il peut être plus utile de se référer à l'article suivant sur Arithmétique modulaire , car l'ajout modulaire est un peu différent des opérations modulaires dont nous avons parlé plus tôt.

La formule de cette étape de l’algorithme est :

(X + Y) mod Z

Où:

X – 01234567 (le vecteur d'initialisation A, une valeur prédéfinie dont nous avons discuté dans le Les vecteurs d'initialisation de l'algorithme MD5 section)

Y – fedcba98 (le résultat de la fonction F de l'étape précédente)

Z – 100000000 (c'est l'équivalent de 2³²(ce qui garantit que le résultat de cette équation ne comporte pas plus de huit caractères)

Quand on met tout dans notre formule, on obtient :

(01234567 + fedcba98) mod 100000000

Nous utiliserons ceci calculateur en ligne pour faire l'opération modulo. Tout d'abord, sélectionnez hexadécimal pour « Numéro un type', 'Numéro b type', 'Numéro c type » et « Convertir le résultat du calcul en a ». Encore une fois, nous devrons diviser l’opération en plusieurs parties, car cette calculatrice n’autorise pas non plus les parenthèses.

Entrer:

01234567 dans « Nombre un valeur'.

fedcba98 dans « Nombre b valeur'.

Taper ' ajouter(a,b) » dans le champ où il est écrit « Équation de calcul ». Cela indique simplement à la calculatrice d'additionner les nombres que nous avons saisis pour A et B. Cela nous donne le résultat suivant :

ffffffff

Pour l'étape suivante, saisissez :

ffffffff dans « Nombre un valeur'.

100000000 dans « Nombre b valeur'.

mod(a,b) dans « Équation de calcul ».

Si vous avez tout fait correctement, lorsque vous cliquez Calculer , vous devriez obtenir la réponse suivante :

ffffffff

Si vous ne comprenez toujours pas le fonctionnement de ces calculs, c'est peut-être une bonne idée de consulter le lien arithmétique modulaire publié ci-dessus. Une autre option consiste à convertir les nombres hexadécimaux en nombres décimaux . En convertissant les nombres en décimaux et en effectuant les calculs dans un système numérique que vous connaissez mieux, cela pourrait vous aider à comprendre ce qui se passe réellement. Vous pouvez ensuite reconvertir votre réponse en hexadécimal pour voir si elle est la même.

Le premier p ortion de notre entrée de message

Maintenant que nous avons le résultat de cette première boîte d’addition modulaire, il est temps de passer à autre chose. Si vous suivez la ligne qui quitte la boîte, vous verrez qu'elle pointe vers une autre des mêmes boîtes d'addition modulaires. À gauche de cette case, nous voyons une flèche avec Mi pointant également vers elle. Ceux-ci représentent nos deux entrées dans le prochain calcul.

Si vous vous souvenez de ce dont nous avons discuté au début de L'entrée M section, chaque bloc de 512 entrées est divisé en seize « mots » de 32 bits, étiquetés M0-M15. Lejedans le diagramme se trouve un espace réservé général pour le mot choisi par l'algorithme. Dans ce cas, nous ne faisons que commencer, nous avons donc affaire au premier mot, M0.

Lorsque nous avons divisé notre entrée en seize mots de 32 bits dans L'entrée M section, M0 était 54686579 en hexadécimal.

En plus de notre entrée M0, nous avons également besoin de notre sortie de la dernière étape, ffffffff . La case indique que nous devons effectuer une addition modulaire avec ces deux nombres, tout comme dans la section précédente.

La formule de cette étape de l’algorithme est également :

(X + Y) mod Z

Où:

X - 54686579 (M0)

ET - ffffffff (le résultat de la section précédente)

DEPUIS - 100000000 (c'est 2³²)

Donc:

( 54686579 + fffffff) contre 100000000

Nous allons utiliser le même calculateur en ligne . Cette fois, c’est la même équation, mais avec des entrées différentes, nous allons donc la parcourir beaucoup plus rapidement. Si vous vous perdez, référez-vous simplement à la section précédente et remplacez les valeurs par ces nouvelles entrées.

Entrer:

54686579 dans « Nombre un valeur'.

ffffffff dans « Nombre b valeur'.

ajouter(a,b) dans « Équation de calcul ».

Frappez le Calculer bouton. Il vous donnera une réponse de :

154686578

Copiez cette valeur et insérez-la dans « Nombre un champ 'valeur'. Insérer 100000000 dans « Nombre b valeur'. Changez la formule en mod (a,b) . Si vous avez tout fait correctement, lorsque vous cliquez sur Calculer, vous devriez obtenir une réponse de :

54686578

Avec ce résultat en main, il est temps de passer à l’étape suivante.

Ajout de la constante

En revenant à notre diagramme, lorsque nous suivons la ligne de la case précédente, nous voyons encore une autre des cases qui indiquent un ajout modulaire. Cette fois, nous avons besoin que notre sortie de la dernière opération agisse comme une entrée, ainsi que ce que le diagramme appelle Ki.

K fait référence à une constante, il en existe 64 différentes, une pour chacune des opérations impliquées dans le traitement d'un bloc de 512 bits.jeest juste un espace réservé pour la constante que nous préparons. Puisqu'il s'agit toujours de la première opération, nous utiliserons K1 en premier (la RFC n'indique pas pourquoi le message saisi, M commence à M0, alors que la constante commence à 1). Chacune des valeurs de K est indiquée dans le Les opérations section. Si vous y revenez, vous verrez que K1 est :

d76aa478

Encore une fois, notre fonction est :

(X + Y) mod Z

Nos valeurs sont :

X - d76aa478

ET - 54686578 (le résultat de l'opération précédente)

DEPUIS - 100000000 (deux³²)

Quand on branche le tout, on obtient :

(d76aa478 + 54686578) mod 100000000

Utiliser le même calculateur en ligne , nous saisissons les entrées suivantes :

d76aa478 dans « Nombre un valeur'.

54686578 dans « Nombre b valeur'.

ajouter(a,b) dans « Équation de calcul ».

Frappez le Calculer bouton. Il vous donnera une réponse de :

12bd309f0

Copiez cette valeur et insérez-la dans « Nombre un champ 'valeur'. Insérer 100000000 dans « Nombre b valeur'. Changez la formule en mod (a,b). Si vous avez tout fait correctement, lorsque vous cliquez sur Calculer, vous devriez obtenir une réponse de :

2bd309f0

Ce qui précède est notre résultat pour cette étape de l’opération.

Gauche peu- changement

Lorsque nous suivons à nouveau les flèches, nous voyons une boîte avec plusieurs symboles pointant vers la gauche. Cela signifie que nous devons prendre notre entrée de l’opération précédente et la déplacer vers la gauche. Le nombre d'espaces que nous décalons dépend du tour, selon les valeurs prédéfinies que nous avons listées dans le Les opérations section.

Puisque c'est la première fois que nous exécutons la fonction, nous commençons par S1. Si vous consultez le listing, vous verrez que la valeur de S1 est 7. Cela signifie que nous devons décaler notre valeur de sept espaces vers la gauche. Comme pour tout ce que font les ordinateurs, cela se produit au niveau binaire, et il nous sera plus facile de voir ce qui se passe si nous reconvertissons temporairement notre nombre hexadécimal en binaire.

Reprenons donc le résultat de notre étape précédente :

2bd309f0

Et utilisez un convertisseur en ligne pour le passer en binaire :

0010 1011 1101 0011 0000 1001 1111 0000

Il suffit de déplacer chaque bit de 7 espaces vers la gauche. Nous le ferons avec une étape intermédiaire pour permettre de voir plus facilement ce qui se passe :

001 0101 1110 1001 1000 0100 1111 1000 0xxx xxxx

Nous avons ajouté aux sept X symboles à droite pour représenter le changement. Cependant, cet espace est en réalité remplacé par les sept chiffres les plus à gauche que nous avons soulignés. La rotation sur sept bits ressemble vraiment à ceci :

1110 1001 1000 0100 1111 1000 0 001 0101

Si nous reconvertissons ce nombre en hexadécimal, nous obtenons :

e984f815

Comme vous pouvez le constater, même si ce décalage de bit vers la gauche semble être une étape relativement similaire, il donne à la chaîne un aspect radicalement différent.

Ajout plus modulaire

En regardant à nouveau le diagramme, lorsque nous traçons les lignes, nous voyons que le résultat de notre décalage vers la gauche va vers une autre boîte d'addition modulaire. L'autre entrée remonte au B en haut, qui est le vecteur d'initialisation B . Si vous vous référez au Les vecteurs d'initialisation de l'algorithme MD5 section, vous verrez que cette valeur est 89abcdef .

À présent, vous devriez être assez familier avec l’ajout modulaire et les étapes que nous avons suivies pour le résoudre. La formule est :

(X + Y) mod Z

Cette fois:

X - 89abcdef (vecteur d'initialisation B)

ET - e984f815 (le résultat de la section précédente)

DEPUIS - 100000000 (deux³²)

Quand on met tous les nombres, on obtient :

(89abcdef + e984f895) mod 100000000

Utilisons notre calculateur en ligne entrer:

89abcdef dans « Nombre un valeur'.

e984f815 dans « Nombre b valeur'.

ajouter(a,b) dans « Équation de calcul ».

Clique le Calculer bouton pour obtenir une réponse de :

17330C604

Il est maintenant temps de copier et d'insérer cette valeur dans « Nombre un champ 'valeur'. Taper 100000000 dans « Nombre b valeur » et changez la formule en mod (a, b) . Cela devrait vous donner une réponse de :

7330C604

La fin… de la première opération

Nous avons pratiquement terminé la première opération. Si vous tracez la flèche partant de la dernière boîte d'addition modulaire sur laquelle nous avons travaillé, elle finit par pointer vers le B en bas. Ces valeurs en bas pour A, B, C et D serviront de vecteurs d'initialisation pour la deuxième opération.

Cela signifie que la sortie de la dernière étape deviendra le vecteur d'initialisation B pour l'opération suivante. Il remplace le vecteur d'initialisation d'origine B, qui était 89abcdef. Si on suit toutes les autres lignes, on se retrouve avec :

• D comme nouveau vecteur d'initialisation pour A.
• La sortie de l’ensemble de l’opération comme vecteur d’initialisation pour B.
• B comme nouveau vecteur d'initialisation pour C.
• C comme nouveau vecteur d'initialisation pour D.

Plus que 63 opérations à effectuer…

Résumé de la première opération

Avant d’aller plus loin, il est préférable de faire un bref résumé des nombreuses étapes compliquées que nous avons traversées.

Nous avons commencé avec nos quatre vecteurs d'initialisation :

• A – 01234567
• B – 89abcdef
• C-fedcba98
• D-76543210

Nous mettons ces trois dernières valeurs via la fonction F :

F(B, C, D) = (B∧C)∨(¬B∧D)

Cela nous a donné un résultat de :

F(B,C,D) = fedcba98

Nous avons pris ce résultat et l'avons mis dans la formule suivante pour une addition modulaire aux côtés du vecteur d'initialisation A :

(X+Y) modZ

Où:

X = 01234567

Y = fedcba98

Z = 1 000 000 000

Cela nous a donné une réponse de :

ffffffff

Ensuite, nous avons fait un ajout plus modulaire, cette fois avec le premier mot de notre entrée initiale, M0, qui est 54686579. Nous l'avons ajouté au résultat de la dernière étape avec la même formule, ce qui nous a donné :

54686578

L'étape suivante consistait en un ajout plus modulaire, cette fois avec une constante, K, dont nous avons répertorié les valeurs dans le Les opérations section. K1 était d76aa478, que nous avons ajouté au résultat précédent, nous donnant un résultat de :

2bd309f0

L'étape suivante a mélangé les choses et nous avons converti le résultat hexadécimal en binaire, afin que nous puissions facilement voir le décalage vers la gauche de sept bits. Lorsque nous l'avons rétabli en hexadécimal, le résultat était :

e984f815

Nous avons suivi cela en revenant à l'addition modulaire, en ajoutant ce résultat au vecteur d'initialisation B, 89abcdef . Nous nous retrouvons avec la valeur suivante, qui devient le vecteur d'initialisation B au tour suivant :

7330c604

Les valeurs de B, C et D ont également été déplacées vers la droite, nous donnant de nouveaux vecteurs d'initialisation pour l'opération suivante :

• A-76543210
• B-7330c684
• C-89abcdef
• D - fedcba98

La deuxième opération

La deuxième opération passe par les mêmes modèles que l'opération précédente, cependant, elle est effectuée avec des valeurs différentes. Non seulement les vecteurs d’initialisation sont différents, mais certaines entrées le sont également. L'opération se déroule selon les axes suivants :

• Les nouvelles valeurs de B, C et D sont passées par la fonction F de la même manière que lors de l'opération précédente.
• Le résultat est ensuite ajouté à la nouvelle valeur de A par addition modulaire.
• Cette fois, le deuxième mot du message d'entrée, M1, est ajouté au résultat de l'étape précédente avec addition modulaire. Selon le L'entrée M section, M1 est 54686579.
• L'arithmétique modulaire est à nouveau utilisée, cette fois en ajoutant le dernier résultat à la constante, qui est K2. K2 est e8c7b756 selon notre liste de valeurs K dans le Les opérations section.
• Nous prenons ensuite le résultat de la dernière section et le décalons vers la gauche. Cependant, au lieu de le déplacer de sept espaces, nous le décalons cette fois de douze. C'est parce que les valeurs que nous avons définies pour les bits de gauche se déplacent dans le Les opérations La section stipule que S2 vaut 12. Ce signal 12 se déplace vers la gauche lors de la deuxième opération.
• Ce résultat est ensuite ajouté à la nouvelle valeur du vecteur d'initialisation B avec l'arithmétique modulaire.
• Le résultat devient le nouveau vecteur d'initialisation B pour la troisième opération. Les valeurs de B, C et D sont également pivotées vers la droite, de sorte que B devienne le vecteur d'initialisation C, C devienne le vecteur d'initialisation D et D devienne le vecteur d'initialisation A.

Subséquent opérations

J’espère que vous avez désormais compris ce qui se passe dans chaque opération individuelle. Les opérations trois à 16 commencent chacune avec les résultats des opérations précédentes comme « vecteurs d'initialisation ». Cependant, ces résultats ont toujours été décalés d’une lettre vers la droite.

Les opérations ultérieures concernent :

• Les valeurs de B, C et D passant par la fonction F.
• Les résultats étant ajoutés aux valeurs A respectives par addition modulaire.
• Les résultats étant ajoutés à la partie respective du message d'entrée, Mi.
• Les résultats étant ajoutés à la constante respective, Ki.
• Les résultats étant décalés, il restait un nombre défini d'espaces, selon le Si.
• Les résultats étant ajoutés au vecteur d'initialisation B et cette valeur devenant le nouveau vecteur d'initialisation B au tour suivant.
• Les trois autres valeurs étant décalées d'un espace vers la droite.

Les valeurs finales de l'opération trois deviennent les vecteurs d'initialisation pour l'opération quatre, et les valeurs finales de l'opération quatre deviennent les vecteurs d'initialisation pour l'opération cinq. Ce modèle se poursuit jusqu'à la 16ème opération, qui utilise les résultats du 15ème tour comme vecteurs d'initialisation. Les résultats de l'opération 16 deviendront des « vecteurs d'initialisation » pour la première opération du deuxième tour.

Deuxième round

Faisons un zoom arrière pendant une minute et examinons la structure globale de l'algorithme. Nous avons réalisé la première série de 16 opérations et nous passons maintenant à la deuxième série. Le diagramme ne rend pas vraiment justice à l’algorithme et n’inclut pas tout, mais s’il le faisait, il deviendrait trop compliqué :

À l'heure actuelle, nous avons les sorties du premier tour, qui deviendront nos vecteurs d'initialisation pour la première opération du deuxième tour dans le deuxième long rectangle.

Les choses changent au début du deuxième tour. Sa première opération, la 17e au total, débute avec une fonction différente. La fonction F est remplacée par la fonction G, qui sera utilisée pour les opérations 17 à 32. La fonction G est la suivante :

G (B, C, D) = (B∧D)∨(C∧¬D)

Les valeurs de B, C et D sont quelles qu’aient été les sorties de l’opération précédente, comme avant. Pour un rappel sur l’algèbre booléenne :

• ∧– ET
• ∨– OU
• ¬ – PAS

La formule dit donc essentiellement : G (B, C, D) est égal à (B ET D) OU (C ET NON D).

Déterminer les valeurs correctes pour chacune des 16 opérations précédentes ne semble pas très amusant, nous allons donc simplement en inventer quelques-unes. Cela vous donnera quand même une idée du fonctionnement de cette nouvelle fonction G, et vous évitera de parcourir des pages de répétition. Disons que la 16ème opération a conduit aux vecteurs d'initialisation suivants pour le 17ème tour :

• UN - 799d1352
• B- 2c34dfa2
• C- de1673be
  
• D - 4b976282

Donc:

G (B, C, D) = (2c34dfa2∧4b976282)∨(de1673be∧¬4b976282)

Nous devrons effectuer le calcul par étapes, car cela calculateur en ligne pour les expressions logiques, n'autorise pas les parenthèses pour ordonner les opérations. Commençons par trouver le résultat de la première partie :

(2c34dfa2∧4b976282)

• Entrez 2c34dfa2 dans l'entrée A.
• Sélectionner ET dans le menu déroulant en dessous.
• Entrez 4b976282 dans l'entrée B.
• Sélectionner Hex à partir des quatre systèmes numériques différents, situés juste en dessous du résultat de l'opération.

Cela nous donne un résultat de :

8144282

Passons maintenant à l’autre moitié de l’équation :

(de1673be∧¬4b976282)

• Supprimez l'ancienne valeur de l'entrée A et placez de1673be là à la place.
• Vous pouvez laisser la même valeur 4b976282 dans l'entrée B, cliquez simplement sur le PAS bouton à gauche de celui-ci.

Vous devriez obtenir le résultat suivant :

1400113c

Maintenant que nous avons les résultats de (B∧D) et (C∧¬D), nous pouvons effectuer l’opération OU.

8144282 ∨ 1400113c

Nous devons:

• Entrer 8144282 dans l’entrée A.
• Sélectionner OU dans le menu déroulant en dessous.
• Entrer 1400113c dans l’entrée B. Assurez-vous que NOT n’est plus sélectionné.
• Sélectionner Hex à partir des quatre systèmes numériques différents, situés juste en dessous du résultat de l'opération.

Cela nous donne un résultat pour G (B, C, D) de :

1c1453be

Cette valeur est ensuite envoyée dans la fonction d'addition modulaire avec le vecteur d'initialisation que nous avons créé pour A. Tout le reste se déroule à peu près de la même manière que lors des opérations décrites ci-dessus, les sorties de l'opération précédente devenant des entrées pour le tour suivant. Chaque opération utilise ses entrées Mi et Ki respectives, ainsi que les décalages Si que nous avons spécifiés dans le Les opérations section.

Troisième tour

Une fois la 32ème opération terminée, ses sorties sont utilisées comme vecteurs d'initialisation pour la 33ème opération. Cependant, comme c'est le début du troisième tour, la fonction H est utilisée d'ici la fin de la 48ème opération. La formule est :

H (B, C, D) = B⊕C⊕D

La fonction H est également fonction de (B, C et D). Le symbole ⊕ à droite de l’équation ne vous est peut-être pas familier. C’est généralement connu comme un GRATUIT opération, abréviation de exclusif ou . En termes pratiques, sa sortie est vraie (dans le sens logique ) si l'un de ses arguments d'entrée est vrai, mais pas si les deux le sont.

Créons quelques sorties du 32ème tour pour agir comme vecteurs d'initialisation pour cette fonction au 33ème tour :

• UNE-eb160cd0
• B-d5071367
• C-c058ade2
• D-63c603d7

Cela nous donne :

H(B, C, D) = d5071367 ⊕ c058ade2 ⊕ 63c603d7

Revenons à notre calculateur en ligne et saisissez cette équation par :

• Entrer d5071367 dans l’entrée A.
• Sélection GRATUIT dans le menu déroulant en dessous.
• Entrer c058ade2 dans l’entrée B.
• Sélection GRATUIT dans le menu déroulant en dessous.
• Entrer 63c603d7 dans l'entrée C.
• Sélection Hex à partir des quatre systèmes numériques différents, situés juste en dessous du résultat de l'opération.

Cela nous donne un résultat pour la fonction H (B, C, D) de :

7699bd52

Tout le reste continue comme ci-dessus, sauf avec leurs valeurs d'entrée respectives pour chaque opération.

Quatrième tour

Quand on arrive à la 49ème opération, c’est l’heure du début du quatrième tour. Nous obtenons une nouvelle formule, que nous utiliserons jusqu'à la fin du 64e tour :

je(B, C, ré) = C⊕(B∨¬D)

Cette formule possède également la fonction XOR pour l'un ou l'autre, mais pas pour les deux. Cela signifie essentiellement « C OU, MAIS PAS LES DEUX (B OU NON-D). Rassemblons quelques résultats supplémentaires de la fin du 48e tour :

• UN - 60cdceb1
  
• B- 7d502063
  
• C- 8b3d715d
  
• D - 1de3a739

Donc:

je (B, C, ré) = 8b3d715d⊕(7d502063∨¬1de3a739)

Faisons d’abord la partie entre parenthèses de l’opération dans notre calculateur en ligne. Saisissez-le par :

• Placer 7d502063 dans l'entrée A.
• Sélection OU dans le menu déroulant en dessous.
• Saisir 1de3a739 dans l’entrée B.
• Sélection en cliquant PAS à côté de l'entrée B.
• Sélection Hex à partir des quatre systèmes numériques différents, situés juste en dessous du résultat de l'opération.

Cela nous donne un résultat de :

7f5c78e7

Le reste de l'équation est donc :

8b3d715d ⊕ 7f5c78e7

Pour le terminer :

• Lieu 8b3d715d dans l’entrée A.
• Sélectionner GRATUIT dans le menu déroulant en dessous.
• Entrez le résultat de notre dernier calcul, 7f5c78Ee7 , dans l’entrée B (assurez-vous que le NON à côté n’est plus sélectionné).
• Sélectionner Hex à partir des quatre systèmes numériques différents, situés juste en dessous du résultat de l'opération.

Cela nous donne un résultat de :

f46109ba

La suite de cette opération se poursuit de la même manière que chacune des opérations précédentes. Ce résultat est ajouté au vecteur d'initialisation A avec l'arithmétique modulaire, et chacune des autres étapes est suivie avec les valeurs d'entrée respectives pour ce tour. Au final, cela nous donne des sorties qui servent de vecteurs d'initialisation pour l'opération 50, qui utilise également la fonction I.

Ce processus se poursuit jusqu'au (et y compris) le 64e tour.

La dernière étape de l'algorithme MD5, après 64 opérations

La 64ème opération se déroule comme chacune de celles qui la précèdent, en utilisant les sorties de la 63ème opération comme vecteurs d'initialisation pour la fonction I. Lorsqu’il a parcouru chacune des étapes de l’opération, il nous donne de nouvelles valeurs pour A, B, C et D.

Disons que ces valeurs sont :

• A-60cdceb1
• B-7d502063
• C-8b3d715d
• D-1de3a739

Tout d’abord, nous allons à nouveau effectuer un zoom arrière et examiner l’algorithme MD5 plus grand :

À ce stade, nous avons terminé le rectangle du bas qui dit « 16 opérations de… ». Si vous suivez les flèches vers le bas, vous verrez qu'elles sont connecté à un boitier avec quatre calculs d'addition modulaires . Les autres entrées proviennent des vecteurs d'initialisation que nous avons utilisés au tout début de l'algorithme MD5.

Pour cette étape, appelons-les OIV-A, OIV-B, etc. pour le vecteur d'initialisation d'origine A, B, etc.. Cela devrait aider à garder les choses claires. Ces vecteurs d'initialisation originaux étaient :

• OIV-A – 01234567
• OIV-B - 89abcdef
  
• OIV-C – fedcba98
  
• OIV-D – 76543210

Encore une fois, notre équation pour l’addition modulaire est :

(X + Y) mod Z

Dans ce cas:

• X - 60cdceb1 (La sortie du vecteur d'initialisation A après la 64ème opération).
• ET - 01234567 (OIV-A).
• DEPUIS - 100000000 (c'est 232).

Donc:

(60cdceb1 + 01234567) mod 100000000

Revenons à notre calculateur en ligne pour ajout modulaire. Encore une fois, nous devrons faire cette équation par étapes, car la calculatrice n’autorise pas les parenthèses. Additionnons les deux premiers nombres en entrant :

• 60cdceb1 dans « Nombre un valeur'.
• 01234567 dans « Nombre b valeur'.

Mettre ' ajouter(a,b) » dans « Équation de calcul ». Assurez-vous d'avoir Hexadécimal sélectionné pour « Nombre un type', 'Numéro b type » et « Convertir le résultat du calcul en a ».

Clique le Calculer bouton pour obtenir une réponse de :

61f11418

Il est maintenant temps de copier et d'insérer cette valeur dans « Nombre un champ 'valeur'. Taper 100000000 dans « Nombre b valeur » et changez la formule en « mod (a,b). » Cela devrait vous donner une réponse de :

61f11418

C'est la réponse pour la valeur finale de A (dans le cas d'un seul bloc de 512 bits de données d'entrée).

Les trois derniers calculs de l'algorithme MD5

Nous devons faire exactement la même équation pour nos nombres restants :

(A + B) mod C

Il nous faut donc résoudre :

• (B + OIV-B) contre C
• (C + OIV-C) mode C
• (D+OIV-D)mod C

Quand on branche les numéros respectifs, on obtient :

• (7d502063 + 89abcdef) mod 100000000
• (8b3d715d + fedcba98) mod 100000000
• (1de3a739 + 76543210) mod 100000000

À présent, vous devriez être assez familier avec le fonctionnement de chacune de ces équations, vous devriez donc être capable de les calculer vous-même si vous le souhaitez. Si vous voulez éviter le travail acharné, les réponses sont :

• B- 06fbee52 (la calculatrice vous donnera en fait une réponse de 6fbee52. Nous avons simplement ajouté le zéro au début pour le porter à huit caractères)
• C- 8a1a2bf5
• D - 9437d949

Le hachage d'une fonction de hachage MD5

Étant donné que nous calculons uniquement le hachage d’un seul bloc de données de 512 bits, nous disposons de toutes les informations dont nous avons besoin pour le hachage final. Il s’agit simplement d’une concaténation (c’est juste un mot sophistiqué qui signifie que nous mettons les nombres ensemble) de ces dernières valeurs pour A, B, C et D :

Hachage = ABCD

Par conséquent, le hachage de notre message original « Ils sont déterministes » est :

H (Ils sont déterministes) = 61f1141806fbee528a1a2bf59437d949

Entrées de messages plus grandes

Si l'entrée initiale était de 448 bits ou plus, elle devra être divisée en deux blocs ou plus de 512 bits. Dans le premier bloc, l’entrée serait ajoutée essentiellement de la même manière que nous l’avons décrit tout au long. La seule différence réside dans la dernière étape.

Après l'opération 64, les résultats pour A, B, C et D sont ajoutés à OIV-A, OIV-B, OIV-C et OIV-D en utilisant une addition modulaire, comme ci-dessus. Cependant, ces résultats ne seraient pas concaténés pour former le hachage final .

Au lieu de cela, le résultat de A + OIV-A agirait comme vecteur d'initialisation A pour le début du deuxième bloc de données de 512 bits. Les résultats de B + OIV-B, C + OIV-C et D + OIV-D formeraient respectivement les vecteurs d'initialisation pour B, C et D dans ce deuxième bloc de données de 512 bits.

Les 512 bits d'entrée suivants seraient divisés en seize mots de 32 bits, tout comme les 512 bits de données initiaux. Chacun de ces nouveaux mots deviendrait M0, M1, M2…M15 pour que l’algorithme MD5 s’exécute à nouveau. Toutes les autres variables seraient les mêmes que dans les étapes précédentes.

Il y aurait quatre séries de 16 opérations chacune, pour un total de 64 opérations. Chaque tour aurait sa propre fonction, les fonctions F, G, H et I, qui seraient utilisées dans le même ordre et de la même manière que la dernière fois.

Si l'entrée initiale ne comportait que deux blocs de 512 bits, les dernières parties de l'algorithme de hachage MD5 se dérouleraient essentiellement de la même manière que dans l'algorithme de hachage MD5. La dernière étape, après 64 opérations section, produisant finalement le hachage pour les deux blocs de 512 bits de données d'entrée .

Si l'entrée initiale comptait plus de deux blocs de 512 bits, les sorties A, B, C et D qui auraient autrement formé le hachage sont plutôt utilisées comme vecteurs d'initialisation pour le troisième bloc.

Ce processus se poursuivra jusqu'à ce que toutes les entrées initiales aient été traitées, quel que soit le nombre de blocs de 512 bits nécessaires. Chaque fois qu'il s'agit du dernier bloc, l'algorithme suivra le processus décrit dans le La dernière étape, après 64 opérations section, nous fournissant finalement de nouvelles valeurs pour A, B, C et D. Celles-ci seraient ensuite concaténées pour former le hachage.

L'algorithme MD5

L’algorithme MD5 semble être un processus ardu lorsque l’on suit chacune des étapes, mais nos ordinateurs sont capables de tout faire en un instant. Bien que cela représente beaucoup de travail pour nous, ce processus aboutit à un algorithme qui peut être très utile pour des choses comme la vérification de l'intégrité des données. Découvrez la fonction de hachage MD5, ses autres utilisations, ses failles de sécurité et bien plus encore dans notre Qu’est-ce que MD5 et comment est-il utilisé ? article.