Cómo utilizar md5 en Delphi

Copie el siguiente código en una celda y guárdelo como MD5.pas. En el proyecto DELPHI, use SHIFT F11 para agregar MD5.pas al proyecto. En las unidades que desee cotizar utilice md5.

Luego puedes usar las funciones internas para implementar el cifrado MD5 Md5string y Md5File.

// tabs = 2

// -

//

//Resumen de mensajes MD5 para Delphi 4

p>

//

// Implementación de la unidad Delphi 4

// Algoritmo de resumen de mensajes MD5 de RSA Data Security Company

//

//Implementación de Ronald L. Leevester RFC 1321

//

//¿Derechos de autor? 1997-1999 Medienagentur Fichtner & Meyer

//Autor Matthias Fichtner

//

// -

Declaración de derechos de autor y licencia de RSA Data Security se puede encontrar en RFC 1321!

// -

//

// 14-Jun-97 mf implementa MD5 según RFC 1321 RFC 1321

/ / 16-jun-97 mf lanzamiento inicial de la unidad de compilación (sin código fuente) RFC 1321

// 28-feb-99 mf agrega la función MD5Match RFC 1321 para comparar dos resúmenes

// 13-Sep-99 mf reelabora todo el dispositivo RFC 1321

// 17-Sep-99 mf reelabora el proyecto "test driver" RFC 1321

//19 -Sep -99 Lanzamiento del código fuente para la unidad MF MD5 y el proyecto "controlador de prueba" RFC 1321

//

// -

//MD5 .pas La última versión está disponible en

//El sitio de distribución está en:

// -

//Este código se proporciona "tal cual" sin expresa o

//GARANTÍAS IMPLÍCITAS DE CUALQUIER TIPO. Úselo bajo su propio riesgo.

// -

Unidad md5

// -

Conexión

// -

Usando

Windows

Tipo

MD5Count = matriz[0..DWORD de 1];

MD5State = matriz [0..3] DWORD

MD5Block = matriz[0..DWORD 15];

MD5CBits = matriz[0..7] bytes;

MD5Digest = matriz[0..15] bytes;

MD5Buffer = matriz[0..63] bytes;

MD5Context = registro

Estado: MD5State

Recuento: MD5Count

Búfer: MD5Buffer

Fin;

Proceso MD 5 init(var Contexto: MD 5 Context);

Actualización del proceso MD 5 (var Contexto: Contexto MD 5; entrada: pChar longitud: palabra larga);

Proceso MD 5 final(var Contexto: Contexto MD 5; var Digest: MD 5 Resumen);

Función MD 5 cadena (M: cadena): MD 5 resumen;

Función MD 5 archivo (N: cadena): MD 5 resumen;

Función MD 5 print(D: resumen MD 5): cadena;

Función MD5Match(D1, D2: resumen MD 5): booleano;

// -

Rendimiento

// -

Definir variables

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

);

Función F(x, y, z :DWORD):DWORD;

Inicio

Resultado: = (x e y) o ((no x) y z);

Fin;

p>

Función G(x, y, z: DWORD): DWORD;

Inicio

Resultado: = (x y z) o (y y (no z)

Fin;

Función H(x, y, z: DWORD):

Inicio

Resultado: = x xor y xor z; ;

p>

Fin;

Función I(x, y, z: DWORD): DWORD;

Inicio

Resultado: = y xor (x o (no z));

Fin;

Proceso rot(var x: DWORD; n: byte

Inicio

< p); >x:= (x shl n) o (x SHR(32-n));

Fin;

Proceso FF (variable a: DWORD; b, c, d , x: DWORD; s: byte; AC: DWORD);

Inicio

inc(a, F(b, c, d) x AC); >rot(a, s);

inc(A, B);

Fin;

Proceso GG (variable a: DWORD; b, c, d, x: DWORD; s: byte; AC: DWORD);

Inicio

inc(a,G(b,c,d) x AC);

rot(a, s);

inc(A, B);

Fin;

Proceso HH (variable a: DWORD ; b, c, d, x: DWORD; s: byte; AC: DWORD);

Inicio

inc(a,H(b,c,d) x AC

rot(a, s);

inc(A, B);

Fin;

Proceso II (variable a: DWORD; b, c, d, x: DWORD; s: byte; AC: DWORD

inc(a, I(b, c, d ) x AC);

rot(a, s);

inc(A, B

Fin

/ / -

//Codifique el byte de conteo en la ubicación de origen en una palabra doble (Conteo / 4) en la ubicación de destino

Codificación del proceso (origen, destino: puntero; conteo: palabra larga <); /p>

Definir variables

s: PByte;

t: palabra PD;

I: palabra larga

inicio

s:=Fuente;

T:=destino;

Para I:=1, cuenta div 4 inicio

t ^:= s^;

Empresa;

t^:= t^ or(s^ SHL 8);

Empresa;

p>

T^:= T^ o (s^ SHL 16);

Empresa;

t^:= t^ o (s^ SHL 24) ;

Empresa;

Inc(T);

Fin;

Fin;

//En el objetivo Decodificar el recuento de palabras dobles en el origen en (Conteo * 4) bytes

Procesar decodificación (origen, destino: puntero; recuento: palabra larga);

Definir variables

s: palabra PD;

t: PByte;

I: palabra larga;

Inicio

s: = Fuente;

T := Destino

Para I := 1, comience a contar

T^ := S^ y $ff

Inc(T);

T^:= (S^ shr 8) y $ff

Inc(T);

T^: = (S^ shr 16) y $ ff

Inc(T);

T^:

= (S^ shr 24) y $ ff

Inc(T);

Empresa;

Fin;

Fin;

//Convierte el estado según los primeros 64 bytes del búfer

Conversión del proceso (búfer: puntero; estado var: estado MD 5);

Variables de definición

a, b, c, d: DWORD;

bloque: bloque MD 5;

Inicio

Codificar(Buffer, @ Bloque, 64);

a:= Estado[0];

b:= Estado[1];

c:= Estado[2] ;

d:= Estado[3];

FF (a, b, c, d, Bloque[ 0], 7, $ d 76 aa 478

);

FF(d,a,b,c,Bloque[1],12,$E8 c7b 756);

FF(c,d,a,b,Bloque[2],17 , $242070 db);

FF (b, c, d, a, Bloque[3], 22, $c 1 BDC eee);

FF (a, b, c, d,Bloque[4],7,$f 57 c 0 faf);

FF (d,a,b,c,Bloque[5],12,$4787 c62a);

FF p>

FF (c,d,a,b,Bloque[6],17,$a 8304613);

FF (b,c,d,a,Bloque[7 ],22, $FD 469501);

FF (a, b, c, d, Bloque[8], 7, $698098 D8); , b, c, Bloque[9], 12, $8b 44 f 7 af);

FF (c, d, a, b, Bloque[10], 17, $ffff 5b b 1) ;

FF p>

FF (b, c, d, a, Bloque[11], 22, $895 CD 7 be);

FF (a, b, c, d, Bloque[12] ,7,$6b 901122);

FF (d,a,b,c,Bloque[13],12,$FD 987193);

FF (c,d, a, b, Bloque[14], 17, $a 679438 e);

FF (b, c, d, a, Bloque[15], 22, $49 b 40821);

GG (a, b, c, d, Bloque[ 1], 5, $ f 61e 2562);

GG (d, a, b, c , Bloque[ 6], 9, $ c 040 b 340

GG (c, d, a, b, Bloque[11], 14, $ 265 e5a

<); p>GG (b, c, d, a, Bloque[ 0], 20, $ e 9 b 6 c 7 aa);

GG (a, b, c, d, Bloque[ 5] , 5, $ d62f 105d);

GG (d, a, b, c, Bloque[10], 9,

GG (c, d, a,); b, Bloque[15], 14, $d8a 1e 681);

GG (b, c, d, a, Bloque[4], 20, $e 7d 3 FBC 8);<

/p>

GG (a, b, c, d, Bloque[9], 5, $21e 1 CDE 6);

GG (d, a, b, c, Bloque[14 ] ], 9, $c 33707d 6);

GG (c, d, a, b, Bloque[ 3], 14, $f 4d 50d 87); ( b,c,d,a,Bloque[8],20,$455 a 14ed);

GG (a,b,c,d,Bloque[13],5,$a9e 3 e 905 );

GG (d, a, b, c, Bloque[2], 9, $ fcefa 3 f 8);

GG (c, d, a, b, Bloque[7],14,$676 f02d 9);

GG (b,c,d,a,Bloque[12],20,$8d 2 a4 c 8 a);

HH (a, b, c, d, Bloque [ 5], 4, $fffa 3942

HH (d, a, b, c, Bloque [ 8], 11, $ 8771f); 681);

HH (c, d, a, b, Bloque[11], 16, $6d9d

HH (b, c, d, a, Bloque). [14], 23, $ FDE 5380 c);

HH (a, b, c, d, Bloque[ 1], 4, $ a4 beea 44); (d, a, b, c, Bloque [ 4], 11, $ 4 bdecfa 9

HH (c, d, a, b, Bloque [ 7], 16, $ f 6 bb); 4b 60);

HH (b, c, d, a, Bloque[10], 23, $ befbc 70

HH (a, b, c, d , Bloque[13],4,$289 b7ec 6);

HH (d,a,b,c,Bloque[0],11,$EAA 127 fa);

HH (c,d,a,b,Bloque[3],16,$d4ef 3085);

HH (b,c,d,a,Bloque[6],23,$4881d 05 );

HH (a, b, c, d, Bloque[9], 4, $d9d 4d 039);

HH (d, a, b, c, Bloque [12 ],11,$e 6 db 99 e 5);

HH (c,d,a,b,Bloque[15],16,$1fa 27 cf 8);

HH (b,c,d,a,Bloque[2],23,$c4ac 5665);

II (a,b,c,d,Bloque[0],6,$ f 4292244 );

II (d, a, b, c, Bloque[7], 10, $432 aff 97);

II (c, d, a, b ,Bloque[ 14],15,$ab 9423 a 7);

II (b,c,d,a,Bloque[5],21,$fc93a 039);

II ( a, b, c, d, Bloque[12], 6, $655 b 59 c 3);

II (d, a, b, c, Bloque[3], 10, $8f 0 CCC 92);

II (c, d, a, b, Bloque[10]

, 15, $ffeff 47d);

II (b, c, d, a, Bloque[1], 21, $85845 DD 1); c,d,Bloque[8],6,$6fa 87 e 4 f);

II (d,a,b,c,Bloque[15],10,$ Fe 2 ce 6 e 0 );

II (c, d, a, b, Bloque[6], 15, $a 3014314);

II (b, c, d, a, Bloque [ 13], 21, $4e 0811a 1);

II (a, b, c, d, Bloque[4], 6, $f 7537 e 82);

II (d, a, b, c, Bloque[11], 10, $ bd3af 235);

II (c, d, a, b, Bloque[2], 15, $2 ad 7d 2 bb );

II (b, c, d, a, Bloque[9], 21, $eb86d 391);

inc(Estado[0], a); p>

inc(Estado[1], b);

inc(Estado[2], c);

inc(Estado[3], d);

Fin;

// -

//Inicializar el contexto dado

Proceso MD 5 init(var Context: MD 5 Context) ;

Iniciar

Iniciar desde el contexto

estado[0]: = $67452301;

estado[1]: =$EFC dab 89;

estado[2]:=$98 cfe malo;

estado[3]:=$10325476;

cuenta[0]:= 0;

cuenta[1]:= 0;

MemoriaCero(@Buffer, TamañoDe(MD 5 Buffer));

Fin;

End;

//Actualiza el contexto dado para que contenga los bytes de longitud de entrada

Procedimiento MD 5 update(var Context: MD 5 Context; input: pChar length: long word);

Definir variable

Índice: palabra larga

PartLen: palabra larga;

I: palabra larga

Inicio;

Comenzar desde el contexto

Índice := (Count[0] shr 3) y $3f

inc(count[ 0], length SHL 3);

Si Count[0] lt; (longitud shl 3) entonces inc(count[1]);

inc(Count[1], Longitud SHR 29);

Fin;

PartLen:= 64-Index;

Si longitud gt= PartLen entonces comienza

CopyMemory (@Context. Buffer[Índice], Entrada, PartLen);

Conversión (@Context. Buffer, Context. State

I: = part len;

I 63 lt;longitud inicio

Transformar(@Input[I], contexto.

estado);

inc(I, 64);

Fin

Índice: = 0

fin más I: = 0;

CopyMemory(@Context.Buffer[Index], @Input[I], Longitud-I

Fin

//Completo a Dado un contexto determinado, cree un resumen y restablezca el contexto a cero

Procedimiento MD 5 final(var Context: MD 5 Context; var Digest: MD 5 Digest);

Definir variables

Bits: MD5CBits

Índice: palabra larga

pad len: palabra larga;

Inicio

Decodificación ( @Context. Count, @Bits, 2);

Index:=(context.Count[0] shr 3) y $3f

si Index lt56 entonces PadLen:=56- Índice else PadLen := 120-Index;

MD5Update(Context, @PADDING, PadLen

MD5Update(Context, @Bits, 8); Decodificación (@ Contexto.

Estado, @Digest, 4);

ZeroMemory(@Context, SizeOf(MD 5 Context));

Fin;

// -

//Crear un resumen del mensaje dado

Función MD 5 string(M: string): MD 5 digest;

Definir variables

Contexto: MD5Context

Inicio

MD5Init(Contexto);

MD5Update(Contexto, pChar(M), longitud(M));

MD5Final(context, result);

End;

//Crear un resumen de archivo con el nombre dado

Función MD 5 file(N: string ) ：MD 5 digest;

Definir variables

identificador de archivo: THandle;

identificador de mapa: THandle

ViewPointer: puntero;

Contexto: MD5Context

Inicio

MD5Init(contexto);

FileHandle:= CreateFile(pChar(N), GENERIC_READ, FILE_SHARE_READ o FILE_SHARE_WRITE,

nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL o FILE_FLAG_SEQUENTIAL_SCAN,

si FileHandle tiene un valor de identificador no válido, intente

map handle:= create mapeo de archivos (identificador de archivo, nil, PAGE_READONLY, 0, 0, nil);

Si MapHandle lt gt0 entonces intente

ver puntero:= MapViewOfFile(identificador de MAP, FILE_MAP_READ, 0, 0, 0);

Si ViewPointer lt gt no existe, inténtelo

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

Finalmente

UnmapViewOfFile(ver puntero);

Fin;

Finalmente

cerrar identificador (identificador de mapa);

Fin;

Finalmente

cerrar identificador(identificador de archivo);

Fin;

MD5Final(contexto, resultado);

Fin;

//Crear una representación hexadecimal del resumen dado

Función MD 5 print(D: MD 5 digest): cadena;

p>

Definir variables

I: byte;

Constante

Número: matriz[0..15] de char =

(' 0 ', ' 1 ', ' 2 ', ' 3 ', ' 4 ', ' 5 ', ' 6 ', ' 7 ', ' 8 ', ' 9 ', ' a ' , 'b', 'c', 'd', 'e', ​​'f');

Inicio

>Resultado:="";

para I:= 0 a 15 hacer Resultado:= Resultado Dígitos[(D[I]SHR 4)y $ 0f] Dígitos[D[I]y $ 0f] ;

Fin;

// -

//Comparar dos resúmenes

Función MD5Match(D1, D2: resumen MD 5) : booleano;

Definir variable

I: byte;

Inicio

I: = 0;

Resultado: =Verdadero;

Mientras resultado y (I lt Empecemos

Resultado: = d 1[I]= D2[I];

inc( 1);

Fin;

Fin;

Fin.