Copiez le code comme suit :
unité MD5;
interface
utilise
Windows, messages, SysUtils, variantes, classes, graphiques, contrôles, formulaires,
Boîtes de dialogue, StdCtrls ;
taper
MD5Count = tableau [0 .. 1] de DWORD ;
MD5State = tableau [0 .. 3] de DWORD ;
MD5Block = tableau [0 .. 15] de DWORD ;
MD5CBits = tableau [0 .. 7] d'octets ;
MD5Digest = tableau [0 .. 15] d'octets ;
MD5Buffer = tableau [0 .. 63] d'octets ;
MD5Context = enregistrement
État : État MD5 ;
Nombre : MD5Count ;
Tampon : MD5Buffer ;
fin;
procédure MD5Init(var Contexte : MD5Context);
procédure MD5Update(var Contexte : MD5Context ; Entrée : PAnsiChar ;
Longueur : mot long);
procédure MD5Final(var Contexte : MD5Context ; var Digest : MD5Digest);
fonction MD5File(N : Chaîne) : MD5Digest ;
fonction MD5Print(D : MD5Digest) : AnsiString ;
fonction MD5F (FileName : AnsiString) : AnsiString ;
fonction MD5S(Str : AnsiString) : AnsiString ;
// MD5F consiste à calculer la valeur MD5 du fichier, MD5S consiste à calculer la valeur MD5 de la chaîne !
var
REMPLISSAGE : MD5Buffer = (80 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $,
00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $,
00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $,
00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $,
00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $, 00 $ );
mise en œuvre
fonction F(x, y, z : DWORD) : DWORD ;
commencer
Résultat := (x et y) ou ((pas x) et z);
fin;
fonction G(x, y, z : DWORD) : DWORD ;
commencer
Résultat := (x et z) ou (y et (pas z));
fin;
fonction H(x, y, z : DWORD) : DWORD ;
commencer
Résultat := x xor y xor z;
fin;
fonction I(x, y, z : DWORD) : DWORD ;
commencer
Résultat := y xor (x ou (pas z));
fin;
procédure rot(var x : DWORD ; N : Octet) ;
commencer
x := (x shl N) ou (x shr (32 - N));
fin;
procédure FF(var a : DWORD ; b, c, D, x : DWORD ; s : Octet ; ac : DWORD) ;
commencer
inc(une, F(b, c, D) + x + ac);
pourrir(a, s);
inc(a, b);
fin;
procédure GG(var a : DWORD ; b, c, D, x : DWORD ; s : Octet ; ac : DWORD) ;
commencer
inc(une, G(b, c, D) + x + ac);
pourrir(a, s);
inc(a, b);
fin;
procédure HH(var a : DWORD ; b, c, D, x : DWORD ; s : Octet ; ac : DWORD) ;
commencer
inc(une, H(b, c, D) + x + ac);
pourrir(a, s);
inc(a, b);
fin;
procédure II(var a : DWORD ; b, c, D, x : DWORD ; s : Octet ; ac : DWORD) ;
commencer
inc(une, je(b, c, ré) + x + ac);
pourrir(a, s);
inc(a, b);
fin;
procédure Encode (Source, Cible : pointeur ; Nombre : mot long) ;
var
s:Poctet;
T : PDWORD ;
I : mot long ;
commencer
s := Source ;
T := Cible ;
pour I := 1 pour compter div 4 faire
commencer
T^ := s^;
Inc(s);
T^ := T^ ou (s^ shl 8) ;
Inc(s);
T^ := T^ ou (s^ shl 16) ;
Inc(s);
T^ := T^ ou (s^ shl 24) ;
Inc(s);
Inc(T);
fin;
fin;
procédure Decode(Source, Target : pointeur ; Count : mot long) ;
var
s : PDWORD ;
T : Poctet ;
I : mot long ;
commencer
s := Source ;
T := Cible ;
pour I := 1 pour compter faire
commencer
T^ := s^ et $FF ;
Inc(T);
T^ := (s^ shr 8) et $FF ;
Inc(T);
T^ := (s^ shr 16) et $FF ;
Inc(T);
T^ := (s^ shr 24) et $FF ;
Inc(T);
Inc(s);
fin;
fin;
procédure Transform(Buffer : pointeur ; var State : MD5State) ;
var
a, b, c, D : DWORD ;
Bloc : MD5Block ;
commencer
Encoder(Buffer, @Block, 64);
a := État[0] ;
b := État[1] ;
c := État[2];
D := État[3] ;
FF(a, b, c, D, Bloc[0], 7, $D76AA478) ;
FF(D, a, b, c, Bloc[1], 12, $E8C7B756) ;
FF(c, D, a, b, Bloc[2], 17, 242070DB $);
FF(b, c, D, a, Bloc[3], 22, $C1BDCEEE);
FF(a, b, c, D, Bloc[4], 7, $F57C0FAF);
FF(D, a, b, c, bloc[5], 12, 4787C62A $);
FF(c, D, a, b, Bloc[6], 17, $A8304613) ;
FF(b, c, D, a, Bloc[7], 22, $FD469501) ;
FF(a, b, c, D, Bloc[8], 7, 698098D8 $) ;
FF(D, a, b, c, Bloc[9], 12, $8B44F7AF) ;
FF(c, D, a, b, Bloc[10], 17, $FFFF5BB1);
FF(b, c, D, a, Bloc[11], 22, 895 $CD7BE) ;
FF(a, b, c, D, bloc[12], 7, 6B901122 $) ;
FF(D, a, b, c, Bloc[13], 12, $FD987193) ;
FF(c, D, a, b, Bloc[14], 17, $A679438E) ;
FF(b, c, D, a, Bloc[15], 22, 49B40821 $ );
GG(a, b, c, D, Bloc[1], 5, $F61E2562) ;
GG(D, a, b, c, Bloc[6], 9, $C040B340) ;
GG(c, D, a, b, Bloc[11], 14, 265E5A51 $);
GG(b, c, D, a, Bloc[0], 20, $E9B6C7AA) ;
GG(a, b, c, D, Bloc[5], 5, $D62F105D) ;
GG(D, a, b, c, Bloc[10], 9, 2 441 453 $);
GG(c, D, a, b, Bloc[15], 14, $D8A1E681) ;
GG(b, c, D, a, Bloc[4], 20, $E7D3FBC8) ;
GG(a, b, c, D, Bloc[9], 5, $21E1CDE6);
GG(D, a, b, c, Bloc[14], 9, $C33707D6) ;
GG(c, D, a, b, Bloc[3], 14, $F4D50D87) ;
GG(b, c, D, a, Bloc[8], 20, $455A14ED) ;
GG(a, b, c, D, Bloc[13], 5, $A9E3E905);
GG(D, a, b, c, Bloc[2], 9, $FCEFA3F8);
GG(c, D, a, b, Bloc[7], 14, 676F02D9 $);
GG(b, c, D, a, Bloc[12], 20, $8D2A4C8A) ;
HH(a, b, c, D, Bloc[5], 4, $FFFA3942);
HH(D, a, b, c, Bloc[8], 11, 8771F681 $);
HH(c, D, a, b, Bloc[11], 16, $6D9D6122) ;
HH(b, c, D, a, Bloc[14], 23, $FDE5380C) ;
HH(a, b, c, D, Bloc[1], 4, $A4BEEA44) ;
HH(D, a, b, c, Bloc[4], 11, $4BDECFA9);
HH(c, D, a, b, Bloc[7], 16, $F6BB4B60) ;
HH(b, c, D, a, Bloc[10], 23, $BEBFBC70);
HH(a, b, c, D, Bloc[13], 4, $289B7EC6) ;
HH(D, a, b, c, Bloc[0], 11, $EAA127FA) ;
HH(c, D, a, b, Bloc[3], 16, $D4EF3085) ;
HH(b, c, D, a, Bloc[6], 23, 4881D05 $);
HH(a, b, c, D, Bloc[9], 4, $D9D4D039) ;
HH(D, a, b, c, Bloc[12], 11, $E6DB99E5);
HH(c, D, a, b, Bloc[15], 16, $1FA27CF8) ;
HH(b, c, D, a, Bloc[2], 23, $C4AC5665) ;
II(a, b, c, D, Bloc[0], 6, $F4292244) ;
II(D, a, b, c, Bloc[7], 10, 432$AFF97) ;
II(c, D, a, b, Bloc[14], 15, $AB9423A7) ;
II(b, c, D, a, Bloc[5], 21, $FC93A039) ;
II(a, b, c, D, bloc[12], 6, 655B59C3 $);
II(D, a, b, c, Bloc[3], 10, $8F0CCC92) ;
II(c, D, a, b, Bloc[10], 15, $FFEFF47D) ;
II(b, c, D, a, Bloc[1], 21, 85845DD1 $);
II(a, b, c, D, Bloc[8], 6, $6FA87E4F) ;
II(D, a, b, c, Bloc[15], 10, $FE2CE6E0) ;
II(c, D, a, b, Bloc[6], 15, $A3014314) ;
II(b, c, D, a, Bloc[13], 21, $4E0811A1) ;
II(a, b, c, D, bloc[4], 6, $F7537E82) ;
II(D, a, b, c, Bloc[11], 10, $BD3AF235) ;
II(c, D, a, b, Bloc[2], 15, $2AD7D2BB) ;
II(b, c, D, a, Bloc[9], 21, $EB86D391) ;
inc(État[0], a);
inc(État[1], b);
inc(État[2], c);
inc(État[3], D);
fin;
procédure MD5Init(var Contexte : MD5Context);
commencer
avec le contexte faire
commencer
État[0] := 67452301 $ ;
État[1] := $EFCDAB89;
État[2] := 98 $BADCFE ;
État[3] := 1 0325476 $ ;
Compte[0] := 0;
Compte[1] := 0;
ZeroMemory (@Buffer, SizeOf (MD5Buffer));
fin;
fin;
procédure MD5Update(var Contexte : MD5Context ; Entrée : PAnsiChar ;
Longueur : mot long);
var
Index : mot long ;
PartLen : mot long ;
I : mot long ;
commencer
avec le contexte faire
commencer
Index := (Count[0] shr 3) et $3F ;
inc(Count[0], Longueur shl 3);
si Count[0] < (Longueur shl 3) alors
inc(Compte[1]);
inc(Count[1], Longueur shr 29);
fin;
PartLen := 64 - Index;
si Longueur >= PartLen alors
commencer
CopyMemory (@Context.Buffer[Index], Entrée, PartLen);
Transformation (@Context.Buffer, Context.State);
Je := PartLen;
tandis que I + 63 < Longueur do
commencer
Transform (@Input[I], Context.State);
inc(I, 64);
fin;
Indice := 0;
fin
autre
Je := 0;
CopyMemory (@Context.Buffer[Index], @Input[I], Longueur - I);
fin;
procédure MD5Final(var Contexte : MD5Context ; var Digest : MD5Digest);
var
Bits : MD5CBits ;
Index : mot long ;
PadLen : mot long ;
commencer
Décoder (@Context.Count, @Bits, 2);
Index := (Context.Count[0] shr 3) et $3F ;
si indice < 56 alors
PadLen := 56 - Index
autre
PadLen := 120 - Indice ;
MD5Update(Contexte, @PADDING, PadLen);
MD5Update (Contexte, @Bits, 8);
Décoder (@Context.State, @Digest, 4);
ZeroMemory (@Context, SizeOf (MD5Context));
fin;
fonction MD5String(M : AnsiString) : MD5Digest ;
var
Contexte : MD5Context ;
commencer
MD5Init (Contexte);
MD5Update(Contexte, PAnsiChar(M), Longueur(M));
MD5Final(Contexte, Résultat);
fin;
fonction MD5File(N : Chaîne) : MD5Digest ;
var
Descripteur de fichier : THandle ;
MapHandle : THandle ;
ViewPointer : pointeur ;
Contexte : MD5Context ;
commencer
MD5Init (Contexte);
FileHandle := CreateFile(PWideChar(WideString(N)), GENERIC_READ,
FILE_SHARE_READ ou FILE_SHARE_WRITE, nul, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL ou FILE_FLAG_SEQUENTIAL_SCAN, 0);
si FileHandle <> INVALID_HANDLE_VALUE alors
essayer
MapHandle := CreateFileMapping(FileHandle, nul, PAGE_READONLY, 0, 0, nul);
si MapHandle <> 0 alors
essayer
ViewPointer := MapViewOfFile(MapHandle, FILE_MAP_READ, 0, 0, 0);
si ViewPointer <> nul alors
essayer
MD5Update (Contexte, ViewPointer, GetFileSize (FileHandle, néant));
enfin
UnmapViewOfFile(ViewPointer);
fin;
enfin
CloseHandle(MapHandle);
fin;
enfin
CloseHandle(FileHandle);
fin;
MD5Final(Contexte, Résultat);
fin;
fonction MD5Print(D : MD5Digest) : AnsiString ;
var
I : octet ;
const
Chiffres : tableau [0 .. 15] d'Ansichar = ('0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
commencer
Résultat := '';
pour I := 0 à 15 do
Résultat := Résultat + Chiffres[(D[I] shr 4) et $0F] + Chiffres[D[I] et $0F] ;
fin;
fonction MD5Match(D1, D2 : MD5Digest) : booléen ;
var
I : octet ;
commencer
Je := 0;
Résultat := VRAI ;
tandis que Résultat et (je < 16) font
commencer
Résultat := D1[I] = D2[I];
inc(I);
fin;
fin;
fonction MD5S(Str : AnsiString) : AnsiString ;
commencer
Résultat := MD5Print(MD5String(Str));
fin;
fonction MD5F (FileName : AnsiString) : AnsiString ;
commencer
Résultat := MD5Print(MD5File(string(FileName)));
fin;