Bonjour à tous, je me suis lancé dans un projet. Je voudrais hasher un message de N caractères en MD5.
J'ai trouvé le pseudo code sur wiki.
Le problème est que je n epossède pas assez de connaissances pour coder ma source. (j ai pas envie de trouver une source non comprise sur le net)

Je vous poste:

1) Le pseudo code
2) La source avec étape du pseudo code.


1)
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
MD5 peut s'écrire sous cette forme en pseudo-code
 
//Note: Toutes les variables sont sur 32 bits
 
//Définir r comme suit : 
var int[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 int h0 := 0x67452301
var int h1 := 0xEFCDAB89
var int h2 := 0x98BADCFE
var int h3 := 0x10325476
 
//Préparation du message (padding) :
ajouter "1" bit au message
ajouter "0" bits jusqu'à ce que la taille du message en bits soit égale à 448 (mod 512)
ajouter la taille du message codée en 64-bit little-endian au message
 
//Découpage en blocs de 512 bits:
pour chaque bloc de 512 bits du message
    subdiviser en 16 mots de 32 bits en little-endian w[i], 0 ≤ i ≤ 15
 
    //initialiser les valeurs de hachage:
    var int a := h0
    var int b := h1
    var int c := h2
    var int d := h3
 
    //pour 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
                    fin si
              fin si
        fin si
 
        var int temp := d
        d := c
        c := b
        b := ((a + f + k[i] + w[g]) leftrotate 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 int empreinte := h0 concaténer h1 concaténer h2 concaténer h3 //(en little-endian)
2)

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
#include <stdio.h>
#include <conio.h>
#include <math.h>
 
main()
{
      int i;     // boucle diverses
      int f,g;   // variable boucle principale
      int k[64]; // recoit les sinus d'entier de la formule: k[i]=(sin(i + 1))*(pow(2,32))
 
      int r[64]={7,12,17,22,7,12,17,22,7,12,17,22,7,12,17,22,
                 5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
                 4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,
                 6,10,15,21,6,10,15,21,6,10,15,21,6,10,15,21}; // constentes
 
 
      //MD5 utilise des sinus d'entiers pour ses constantes:
      for(i=0;i<64;i++)
      {
                      k[i]=(sin(i + 1))*(pow(2,32));
      }
 
      //Préparation des variables:
      int h0 = 0x67452301;
      int h1 = 0xEFCDAB89;
      int h2 = 0x98BADCFE;
      int h3 = 0x10325476;
 
      //Préparation du message (padding) :
      //ajouter "1" bit au message
      //ajouter "0" bits jusqu'à ce que la taille du message en bits soit égale à 448 (mod 512)
      //ajouter la taille du message codée en 64-bit little-endian au message
 
      //Découpage en blocs de 512 bits:
      //pour chaque bloc de 512 bits du message subdiviser en 16 mots de 32 bits en little-endian w[i], 0 <= i <= 15
 
      //initialiser les valeurs de hachage:
      int a = h0;
      int b = h1;
      int c = h2;
      int d = h3;
 
      //pour principale:
      for(i=0;i<64;i++)
      {
                       if ((i>=0)&&(i<=15))
                          {
                          f=( (b&c) | ( (!b)& d ) );
                          g=i;
                          }
                          else if ((i>=16)&&(i<=31))
                               {
                               f=(d&b) | ((!d)& c); 
                               g=((5*i)+1)%16;
                               }
                               else if ((i>=32)&& (i<=47))
                               {
                               f= b^c^d;
                               g=((3*i)+5)%16;
                               }
                                    else if ((i>=48)&& (i<=63))
                                    {
                                    f= c^( b | (!d) );
                                    g=(7*i)%16;
                                    }
 
      int temp=d;
      d=c;
      c=b;
      // ? b=((a + f + k[i] + w[g]) << r[i]) + b;
      a=temp;                 
      }
 
      //ajouter le résultat au bloc précédent:
      h0=h0 + a;
      h1=h1 + b; 
      h2=h2 + c;
      h3=h3 + d;                    
 
      //FIN : pour chaque bloc de 512 bits du message subdiviser en 16 mots de 32 bits en little-endian w[i], 0 <= i <= 15
 
      //int empreinte = h0 "concaténer" h1 "concaténer" h2 "concaténer" h3 //(en little-endian)
      printf("%x",h0);
      printf("%x",h1);
      printf("%x",h2);
      printf("%x\n",h3);
 
      getch();
      return(0);
}
J'ai des soucis dans les commentaire de la sources.

Merci d'avance.