MD5-Algorithmus in Delphi XE verfügbar

Kopieren Sie den Codecode wie folgt:

Einheit MD5;

Schnittstelle

verwendet

Windows, Nachrichten, SysUtils, Varianten, Klassen, Grafiken, Steuerelemente, Formulare,

Dialoge, StdCtrls;

Typ

MD5Count = Array [0 .. 1] von DWORD;

MD5State = Array [0 .. 3] von DWORD;

MD5Block = Array [0 .. 15] von DWORD;

MD5CBits = Array [0 .. 7] von Byte;

MD5Digest = Array [0 .. 15] von Byte;

MD5Buffer = Array [0 .. 63] von Byte;

MD5Context = Datensatz

Status: MD5State;

Anzahl: MD5Count;

Puffer: MD5Buffer;

Ende;

procedure MD5Init(var Context: MD5Context);

procedure MD5Update(var Context: MD5Context; Input: PAnsiChar;

Länge: Langwort);

procedure MD5Final(var Context: MD5Context; var Digest: MD5Digest);

Funktion MD5File(N: String): MD5Digest;

Funktion MD5Print(D: MD5Digest): AnsiString;

Funktion MD5F(Dateiname: AnsiString): AnsiString;

Funktion MD5S(Str: AnsiString): AnsiString;

// MD5F soll den MD5-Wert der Datei berechnen, MD5S soll den MD5-Wert der Zeichenfolge berechnen!

var

PADDING: 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);

Durchführung

Funktion F(x, y, z: DWORD): DWORD;

beginnen

Ergebnis := (x und y) oder ((nicht x) und z);

Ende;

Funktion G(x, y, z: DWORD): DWORD;

beginnen

Ergebnis := (x und z) oder (y und (nicht z));

Ende;

Funktion H(x, y, z: DWORD): DWORD;

beginnen

Ergebnis := x xor y xor z;

Ende;

Funktion I(x, y, z: DWORD): DWORD;

beginnen

Ergebnis := y xor (x oder (nicht z));

Ende;

procedure rot(var x: DWORD; N: Byte);

beginnen

x := (x shl N) oder (x shr (32 - N));

Ende;

Prozedur FF(var a: DWORD; b, c, D, x: DWORD; s: Byte; ac: DWORD);

beginnen

inc(a, F(b, c, D) + x + ac);

rot(a, s);

inc(a, b);

Ende;

Prozedur GG(var a: DWORD; b, c, D, x: DWORD; s: Byte; ac: DWORD);

beginnen

inc(a, G(b, c, D) + x + ac);

rot(a, s);

inc(a, b);

Ende;

Prozedur HH(var a: DWORD; b, c, D, x: DWORD; s: Byte; ac: DWORD);

beginnen

inc(a, H(b, c, D) + x + ac);

rot(a, s);

inc(a, b);

Ende;

Prozedur II(var a: DWORD; b, c, D, x: DWORD; s: Byte; ac: DWORD);

beginnen

inc(a, I(b, c, D) + x + ac);

rot(a, s);

inc(a, b);

Ende;

procedure Encode(Source, Target: pointer; Count: longword);

var

s:PByte;

T: PDWORD;

I: Langwort;

beginnen

s := Quelle;

T := Ziel;

für I := 1 bis Count div 4 do

beginnen

T^ := s^;

inc(s);

T^ := T^ oder (s^ shl 8);

inc(s);

T^ := T^ oder (s^ shl 16);

inc(s);

T^ := T^ oder (s^ shl 24);

inc(s);

inc(T);

Ende;

Ende;

procedure Decode(Source, Target: pointer; Count: longword);

var

s: PDWORD;

T: PByte;

I: Langwort;

beginnen

s := Quelle;

T := Ziel;

für I := 1 bis Count do

beginnen

T^ := s^ und $FF;

inc(T);

T^ := (s^ shr 8) und $FF;

inc(T);

T^ := (s^ shr 16) und $FF;

inc(T);

T^ := (s^ shr 24) und $FF;

inc(T);

inc(s);

Ende;

Ende;

procedure Transform(Buffer: pointer; var State: MD5State);

var

a, b, c, D: DWORD;

Block: MD5Block;

beginnen

Encode(Buffer, @Block, 64);

a := State[0];

b := State[1];

c := State[2];

D := State[3];

FF(a, b, c, D, Block[0], 7, $D76AA478);

FF(D, a, b, c, Block[1], 12, $E8C7B756);

FF(c, D, a, b, Block[2], 17, $242070DB);

FF(b, c, D, a, Block[3], 22, $C1BDCEEE);

FF(a, b, c, D, Block[4], 7, $F57C0FAF);

FF(D, a, b, c, Block[5], 12, $4787C62A);

FF(c, D, a, b, Block[6], 17, $A8304613);

FF(b, c, D, a, Block[7], 22, $FD469501);

FF(a, b, c, D, Block[8], 7, $698098D8);

FF(D, a, b, c, Block[9], 12, $8B44F7AF);

FF(c, D, a, b, Block[10], 17, $FFFF5BB1);

FF(b, c, D, a, Block[11], 22, $895CD7BE);

FF(a, b, c, D, Block[12], 7, $6B901122);

FF(D, a, b, c, Block[13], 12, $FD987193);

FF(c, D, a, b, Block[14], 17, $A679438E);

FF(b, c, D, a, Block[15], 22, $49B40821);

GG(a, b, c, D, Block[1], 5, $F61E2562);

GG(D, a, b, c, Block[6], 9, $C040B340);

GG(c, D, a, b, Block[11], 14, $265E5A51);

GG(b, c, D, a, Block[0], 20, $E9B6C7AA);

GG(a, b, c, D, Block[5], 5, $D62F105D);

GG(D, a, b, c, Block[10], 9, $2441453);

GG(c, D, a, b, Block[15], 14, $D8A1E681);

GG(b, c, D, a, Block[4], 20, $E7D3FBC8);

GG(a, b, c, D, Block[9], 5, $21E1CDE6);

GG(D, a, b, c, Block[14], 9, $C33707D6);

GG(c, D, a, b, Block[3], 14, $F4D50D87);

GG(b, c, D, a, Block[8], 20, $455A14ED);

GG(a, b, c, D, Block[13], 5, $A9E3E905);

GG(D, a, b, c, Block[2], 9, $FCEFA3F8);

GG(c, D, a, b, Block[7], 14, $676F02D9);

GG(b, c, D, a, Block[12], 20, $8D2A4C8A);

HH(a, b, c, D, Block[5], 4, $FFFA3942);

HH(D, a, b, c, Block[8], 11, $8771F681);

HH(c, D, a, b, Block[11], 16, $6D9D6122);

HH(b, c, D, a, Block[14], 23, $FDE5380C);

HH(a, b, c, D, Block[1], 4, $A4BEEA44);

HH(D, a, b, c, Block[4], 11, $4BDECFA9);

HH(c, D, a, b, Block[7], 16, $F6BB4B60);

HH(b, c, D, a, Block[10], 23, $BEBFBC70);

HH(a, b, c, D, Block[13], 4, $289B7EC6);

HH(D, a, b, c, Block[0], 11, $EAA127FA);

HH(c, D, a, b, Block[3], 16, $D4EF3085);

HH(b, c, D, a, Block[6], 23, $4881D05);

HH(a, b, c, D, Block[9], 4, $D9D4D039);

HH(D, a, b, c, Block[12], 11, $E6DB99E5);

HH(c, D, a, b, Block[15], 16, $1FA27CF8);

HH(b, c, D, a, Block[2], 23, $C4AC5665);

II(a, b, c, D, Block[0], 6, $F4292244);

II(D, a, b, c, Block[7], 10, $432AFF97);

II(c, D, a, b, Block[14], 15, $AB9423A7);

II(b, c, D, a, Block[5], 21, $FC93A039);

II(a, b, c, D, Block[12], 6, $655B59C3);

II(D, a, b, c, Block[3], 10, $8F0CCC92);

II(c, D, a, b, Block[10], 15, $FFEFF47D);

II(b, c, D, a, Block[1], 21, $85845DD1);

II(a, b, c, D, Block[8], 6, $6FA87E4F);

II(D, a, b, c, Block[15], 10, $FE2CE6E0);

II(c, D, a, b, Block[6], 15, $A3014314);

II(b, c, D, a, Block[13], 21, $4E0811A1);

II(a, b, c, D, Block[4], 6, $F7537E82);

II(D, a, b, c, Block[11], 10, $BD3AF235);

II(c, D, a, b, Block[2], 15, $2AD7D2BB);

II(b, c, D, a, Block[9], 21, $EB86D391);

inc(State[0], a);

inc(State[1], b);

inc(State[2], c);

inc(State[3], D);

Ende;

procedure MD5Init(var Context: MD5Context);

beginnen

mit Kontext tun

beginnen

Status[0] := $67452301;

Status[1] := $EFCDAB89;

Status[2] := $98BADCFE;

Status[3] := $10325476;

Anzahl[0] := 0;

Anzahl[1] := 0;

ZeroMemory(@Buffer, SizeOf(MD5Buffer));

Ende;

Ende;

procedure MD5Update(var Context: MD5Context; Input: PAnsiChar;

Länge: Langwort);

var

Index: Langwort;

PartLen: Langwort;

I: Langwort;

beginnen

mit Kontext tun

beginnen

Index := (Count[0] shr 3) und $3F;

inc(Count[0], Länge shl 3);

wenn Count[0] < (Length shl 3) dann

inc(Count[1]);

inc(Count[1], Länge shr 29);

Ende;

PartLen := 64 - Index;

wenn Länge >= PartLen dann

beginnen

CopyMemory(@Context.Buffer[Index], Input, PartLen);

Transform(@Context.Buffer, Context.State);

I := PartLen;

während ich + 63 < Länge tue

beginnen

Transform(@Input[I], Context.State);

inc(I, 64);

Ende;

Index := 0;

Ende

anders

Ich := 0;

CopyMemory(@Context.Buffer[Index], @Input[I], Länge - I);

Ende;

procedure MD5Final(var Context: MD5Context; var Digest: MD5Digest);

var

Bits: MD5CBits;

Index: Langwort;

PadLen: Langwort;

beginnen

Dekodieren(@Context.Count, @Bits, 2);

Index := (Context.Count[0] shr 3) und $3F;

wenn Index < 56 dann

PadLen := 56 - Index

anders

PadLen := 120 - Index;

MD5Update(Context, @PADDING, PadLen);

MD5Update(Context, @Bits, 8);

Dekodieren(@Context.State, @Digest, 4);

ZeroMemory(@Context, SizeOf(MD5Context));

Ende;

Funktion MD5String(M: AnsiString): MD5Digest;

var

Kontext: MD5Context;

beginnen

MD5Init(Kontext);

MD5Update(Context, PAnsiChar(M), Length(M));

MD5Final(Kontext, Ergebnis);

Ende;

Funktion MD5File(N: String): MD5Digest;

var

FileHandle: THandle;

MapHandle: THandle;

ViewPointer: Zeiger;

Kontext: MD5Context;

beginnen

MD5Init(Kontext);

FileHandle := CreateFile(PWideChar(WideString(N)), GENERIC_READ,

FILE_SHARE_READ oder FILE_SHARE_WRITE, nil, OPEN_EXISTING,

FILE_ATTRIBUTE_NORMAL oder FILE_FLAG_SEQUENTIAL_SCAN, 0);

wenn FileHandle <> INVALID_HANDLE_VALUE dann

versuchen

MapHandle := CreateFileMapping(FileHandle, nil, PAGE_READONLY, 0, 0, nil);

wenn MapHandle <> 0 dann

versuchen

ViewPointer := MapViewOfFile(MapHandle, FILE_MAP_READ, 0, 0, 0);

wenn ViewPointer <> nil dann

versuchen

MD5Update(Context, ViewPointer, GetFileSize(FileHandle, nil));

Endlich

UnmapViewOfFile(ViewPointer);

Ende;

Endlich

CloseHandle(MapHandle);

Ende;

Endlich

CloseHandle(FileHandle);

Ende;

MD5Final(Kontext, Ergebnis);

Ende;

Funktion MD5Print(D: MD5Digest): AnsiString;

var

I: Byte;

const

Ziffern: Array [0 .. 15] von Ansichar = ('0', '1', '2', '3', '4', '5', '6', '7',

'8', '9', 'a', 'b', 'c', 'd', 'e', ​​​​'f');

beginnen

Ergebnis := '';

für I := 0 bis 15 tun

Ergebnis := Ergebnis + Ziffern[(D[I] shr 4) und $0F] + Ziffern[D[I] und $0F];

Ende;

Funktion MD5Match(D1, D2: MD5Digest): boolean;

var

I: Byte;

beginnen

Ich := 0;

Ergebnis := TRUE;

während Ergebnis und (I < 16) dies tun

beginnen

Ergebnis := D1[I] = D2[I];

inc(I);

Ende;

Ende;

Funktion MD5S(Str: AnsiString): AnsiString;

beginnen

Ergebnis := MD5Print(MD5String(Str));

Ende;

Funktion MD5F(Dateiname: AnsiString): AnsiString;

beginnen

Ergebnis := MD5Print(MD5File(string(FileName)));

Ende;