Buscando ansiosamente el código fuente del algoritmo de cifrado y descifrado MD5, implementado en C++. ¡Gracias por la puntuación alta!

--------------------------------

Código requerido:

Dos archivos:

--------------------------

1 md5.h:

#pragma once

typedef unsigned long int UINT32;

typedef unsigned short int UINT16;

/* Contexto MD5.*/

typedef struct {

UINT32 estado[4] /* estado (ABCD) */

UINT32 recuento[2] ; * Número de dígitos, módulo 2^64 (lsb tiene prioridad) */

unsigned char buffer[64] /* input buffer */

}MD5_CTX;

void MD5Init (MD5_CTX *);

void MD5Update (MD5_CTX *, unsigned char *, unsigned int);

void MD5Final (unsigned char [16], MD5_CTX * ) ;

--------------------------

2.md5.cpp:

#include "md5.h"

#include "memoria.h"

#define S11 7

#define S12 12< / p>

#definir S13 17

#definir S14 22

#definir S21 5

#definir S22 9

# definir S23 14

#definir S24 20

#definir S314

#definir S32 11

#definir S33 16

#definir S34 23

#definir S41 6

#definir S42 10

#definir S43 15

#definir S44 21

Static void MD5Transform (UINT32 a[4], unsigned char b[64]);

static void Encode (unsigned char*, UINT32 *, unsigned int);

Decodificación vacía estática (UINT32 *, carácter sin firmar *, int sin signo);

Carbón estático sin signo PADDING[64] = {

0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0,

#define F(x, y, z) (((x) & (y))| ((~ x) & (z)))

#define G(x, y, z) (((x) & (z)))|

(~z)))

#definir H(x, y, z) ((x) ^ (y) ^ (z))

#definir I(x, y , z) ((y) ^ ((x) | (~z)))

#define ROTATE_LEFT(x, n) (((x) << (n)))| ) >> (32- (n))))

#define FF(a, b, c, d, x, s, ac) { \

(a) + = F ((b), (c), (d)) + (x) + (UINT32)(ac \

(a) = ROTATE_LEFT ((a), (s)); \

(a) += (b); \

}

#define GG(a, b, c, d, x, s, ac) ) { \

(a) += G ((b), (c), (d)) + (x) + (UINT32)(ac); a) = ROTATE_LEFT ((a), (s)); \

(a) += (b); (a, b, c, d, x, s, ac) { \

(a) += H ((b), (c), (d)) + (x) + (UINT32 )(ac); \

(a) = ROTATE_LEFT ((a), (s)) ; \

(a) += (b);

}

#define II(a, b, c, d, x, s, ac) { \

(a) += I ((b), ( c), (d)) + (x) + (UINT32)(ac);\

(a) = ROTATE_LEFT (( a), (s)); (a) += (b); \

}

void MD5Init (MD5_CTX *contexto)

{

contexto-> ;cuenta[0] = contexto->cuenta[1] = 0;

contexto->estado[0] = 0x67452301;

contexto->estado[1] = 0xefcdab89;

contexto->estado[2] = 0x98badcfe;

contexto- > estado[3] = 0x10325476;

}

void MD5Update (MD5_CTX *context, unsigned char *entrada, unsigned int inputLen)

{

unsigned int i, index, partLen;

index = (unsigned int)((context-> count[0] >> 3) & 0x3F);

if ((context->count[0] += ( (UINT32)inputLen << 3))

< ((UINT32)inputLen << 3))

contexto->cuenta[1]++;

contexto->cuenta

t[1]+= (( UINT32)inputLen >> 29);

partLen = 64 - índice;

if (inputLen >= partLen) {

memcpy((unsigned char *)&context->.buffer[index], (unsigned char *)entrada, partLen);

MD5Transform (contexto->estado, contexto->buffer);

for (i = partLen; i + 63 < ; inputLen; i += 64)

MD5Transform (contexto->estado, &input[i]);

índice = 0;

}

else

i = 0;

memcpy(( unsigned char *)&context->buffer[index ], (carácter sin firmar *)&input[i],

inputLen-i);

}

void MD5Final (resumen de caracteres sin firmar[16], MD5_CTX * contexto)

{

bits de caracteres sin firmar[8];

índice int sin signo, padLen;

Codificar (bits, contexto ->.count, 8);

index = (unsigned int)((context->count[0] >> 3) & 0x3f);

padLen = (index < 56) ?(56 - índice): (120 - índice);

MD5Update (contexto, PADDING, padLen);

MD5Update (contexto, bits, 8);

Codificar (resumen, contexto->.state, 16);

memset ((unsigned char *)context, 0, sizeof (*context));

}

MD5Transform vacío estático (estado UINT32[4], bloque de caracteres sin firmar[64])

{

UINT32 a = estado[0], b = estado [1], c = estado[2], d = estado[3], x[16];

decode(x, block, 64);

/* 1.ª ronda */

FF (a, b, c, d, x[ 0], S11, 0xd76aa478 /* 1 */

FF (d, a, b, c); , x[ 1], S12, 0xe8c7b756); /* 2 */

FF (c, d, a, b, x[ 2], S13, 0x242070db /* 3 */< /); p>

Decodificar(x, bloque, 64);

/* Ronda 1*/