Código fuente del algoritmo de codificación
-
Para codificar:
Dos archivos:
-
1.md5.h:
#Pragma once
typedef unsigned long UINT32
typedef unsigned short uint 16;
/* contexto MD5.
*/
estructura typedef {
estado UINT32 [4]; /* estado (ABCD) */
recuento UINT32 [2]; dígitos, módulo 2^64 (lsb primero)*/
Búfer de caracteres sin firmar [64]; /*Búfer de entrada*/
} MD5 _ CTX;
void MD5 init(MD5 _ CTX *);
void MD5Update (MD5_CTX *, unsigned char *, unsigned int);
void MD5 final(unsigned char[ 16], MD5_CTX *);
-
2.md5.cpp:
#Contiene "md5.h"
#Contiene "memoria. h"
#Definición S11 7
#Definición S12 12
#Definición S13 17
#Definición S14 22
#Definición S21 5
#Definición S22 9
#Definición S23 14
#Definición S24 20
#Definición S31 4
#Definición S32 11
#Definición S33 16
#Definición S34 23
#definir S41 6
#Definición S42 10
#Definición S43 15
#Definición S44 21
Vaciación estática MD5Transform (UINT32 a[4], carácter sin firmar b[64 ]);
Codificación nula estática (unsigned char *, UINT32 *, unsigned int);
Decodificación estática nula (UINT32 *, unsigned char *, unsigned int);
Relleno de caracteres estáticos sin signo [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, 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
};
#Definición F(x, y, z)(( (x) amp; (y)) |((~ x) amp; (z)))
#Definición G(x, y, z) (((x) amp; (z)) |((y) amp; (~ z)))
#Definición H(x, y, z) ((x) ^ (y) ^ (z))
#definir I(x, y, z ) ((y) ^ ((x) | (~z)))
#define ROTATE_LEFT(x, n)(((x) lt; lt( n)) | ((x)> gt(32-(n))))
#Definición FF(a, b, c, d, x, s, ac) { \
(a) = F ( (b), (c), (d)) (x) (uint 32)(AC); \
(a) = ROTATE_LEFT ((a), (s));\
(a) =(b);\
}
#Definición GG(a, b, c, d, x , s, ac) { \
(a) = G ((b), (c), (d)) (x) (uint 32)(AC);
(a) = ROTATE_LEFT ((a), (s) );\
(a) =(b);\
}
#Definición HH(a, b, c, d, x, s, ac) { \
(a) = H ((b), (c), (d)) (x) (uint 32)(AC); ) = ROTATE_LEFT ((a), (s));\
(a) =(b);\
}
#Definición II(a , b, c, d, x, s, ac) { \
(a) = I ((b), (c), (d)) (x) (uint 32)(AC) ;\
(a) = ROTATE_LEFT ((a), (s));\
(a) =(b);\
}
void MD5 init(MD5 _ CTX *contexto)
{
Contexto->;count[0] = contexto->count[1]= 0;
Contexto->;estado[0]= 0x 67452301;
Contexto->;estado[1]= 0x efcdab 89;
Contexto->; estado[2]= 0x 98 cfe incorrecto;
Contexto->; estado[3]= 0x 10325476;
}
actualización nula de MD5(MD5 _ CTX *contexto, entrada de carácter sin signo*, entrada de entero sin signo)
{
unsigned int i, index, partLen
index = (unsigned int )(( contexto- gt; recuento[0] gt; gt3) amp; 0x3F);
if((context- gt; recuento[0] =((uint 32)entrada len lt; lt3) )
lt((uint 32)input len lt; lt3))
Contexto->cuenta[1];
Contexto->cuenta[ 1 ] =((uint 32)input len gt; gt29);
part len = 64-index;
if(input len gt; = partLen) {
memcpy((unsigned char *) & contexto->búfer[índice], (unsigned char *)entrada, partLen);
MD5Transform(context-gt; estado, contexto -gt ;buffer);
for(I = part len;I 63 lt;inputLeni = 64)
MD5Transform(context-gt;state amp input[I]);
Índice = 0;
}
Otro
I = 0;
memcpy((carácter sin firmar* ) amp; contexto->búfer[índice], (carácter sin firmar *) entrada[i],
entrada len-I
}
< p); > anular MD5Final (ningunoResumen de caracteres firmados[16], MD5_CTX * contexto)
{
Bits de caracteres sin firmar[8];
Índice int sin signo, padLen
codificación(bits, contexto->recuento, 8);
índice = (int sin signo)((context-gt;recuento[0]gt;gt3) & 0x3f);
padLen =(index lt; 56) ?(56 - índice): (120 - índice);
MD5Update (contexto, PADDING, padLen);
MD5Update(contexto, bits, 8);
codificación(abstracto, contexto->estado, 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];
Decodificar(x, bloque, 64);
/* Ronda 1 */
FF (a, b, c, d, x[ 0], S11, 0x d 76 a 478 /* 1 */
<) p>FF (d, a, b, c, x[1], S12, 0x e 8 c 7 b 756); x[2],S13,0x 242070 db);/* 3 */FF (b,c,d,a,x[3],S14,0xc 1 BDC eee); */
FF (a, b, c, d, x[4], S11, 0 xf 57 c 0 faf /* 5 */
FF (d, a, b, c, x[ 5], S12, 0x 4787 c62a /* 6 */
FF (c, d, a, b, x[ 6 ], S13, 0xa 8304613) ; /* 7 */
FF (b, c, d, a, x[ 7], S14, 0x FD 469501); /* 8 */
FF (a); , b, c, d, x[ 8], S11, 0x 698098 D8 /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b 44); f 7 af); /* 10 */
FF (c, d, a, b, x[10], S13, 0x ffff 5b b 1);
FF (b, c, d, a, x[11], S14, 0x 895 CD 7 be /* 12 */
FF (a, b, c, d, x); [12], S11, 0x6b 901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0x FD 987193) /* 14 */<; /p>
FF (c, d, a, b, x[14], S13, 0xa 679438 e /* 15 */
FF (b , c, d, a,); x[15], S14, 0x49b 40821); /* 16 */
/*Segunda ronda*/
GG (a, b, c, d, x[1] , S21, 0xf 61e 2562);/
* 17 */
GG (d, a, b, c, x[6], S22, 0xc 040 b 340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x 265 e5a 51 /* 19 */
GG (b, c, d, a, x[ 0], S24, 0x e); 9 b 6 c 7 aa); /* 20 */
GG (a, b, c, d, x[5], S21, 0x d 62 f 105d); /p>
GG (d, a, b, c, x[10], S22, 0x 2441453 /* 22 */
GG (c, d, a, b, x); [15], S23, 0xd8a 1e 681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0x e 7 D3 FBC 8); 24 */
GG (a, b, c, d, x[9], S21, 0x 21e 1 CDE 6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc 33707d 6); /* 26 */
GG (c, d, a, b, x[3], S23, 0x f 4d); 50d 87); /* 27 */
GG (b, c, d, a, x[8], S24, 0x 455 a 14ed); >GG (a, b, c, d, x[13], S21, 0x a 9 e 3 e 905 /* 29 */
GG (d, a, b, c, x); [2], S22, 0x fcefa 3 f 8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x 676 f02d 9); 31 */
GG (b, c, d, a, x[12], S24, 0x 8d 2 a4 c 8 a); Tercera ronda */
HH (a, b, c, d, x[5], S31, 0x fffa 3942 /* 33 */
HH (d, a); , b, c, x[8], S32, 0x 8771f 681 /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d 9d 6122 ) ; /* 35 */
HH (b, c, d, a, x[14], S34, 0x FDE 5380 c); /* 36 */
HH ( a, b, c, d, x[ 1], S31, 0x a4 beea 44 /* 37 */
HH (d, a, b, c, x[ 4], S32 , 0x 4 bdecfa 9); /* 38 */
HH (c, d, a, b, x[7], S33, 0 xf 6 bb 4b 60); p>
HH (b, c, d, a, x[10], S34, 0x befbc 70 /* 40 */
HH (a, b, c, d, x); [13], S31, 0x 289 b 7 EC 6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0x EAA 127 fa/); * 42 */
HH (c, d, a, b, x[3], S33, 0x d4ef 3085); /* 43 */
HH (b, c) ,d,a
, x[ 6], S34, 0x 4881d 05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0x d 9d 4d 039); * 45 */
HH (d, a, b, c, x[12], S32, 0x e 6 db 99 e 5); (c, d, a, b, x[15], S33, 0x 1fa 27 cf 8 /* 47 */
HH (b, c, d, a, x[ 2], S34, 0x C4 AC 5665); /* 48 */
/*Ronda 4*/
II (a, b, c, d, x[ 0], S41, 0xf 4292244); /* 49 */
II (d, a, b, c, x[7], S42, 0x 432 aff 97); >II (c, d, a, b, x[14], S43, 0x ab 9423 a 7 /* 51 */
II (b, c, d, a, x[ 5); ], S44, 0x fc 93 a 039); /* 52 */
II (a, b, c, d, x[12], S41, 0x 655 b 59 c 3); 53 */
II (d, a, b, c, x[3], S42, 0x 8 f 0 CCC 92); , d, a, b, x[10], S43, 0x ffeff 47d /* 55 */
II (b, c, d, a, x[ 1], S44, 0x 85845); DD 1); /* 56 */
II (a, b, c, d, x[8], S41, 0x 6 fa 87 e4f); p>II (d, a, b, c, x[15], S42, 0 xfe 2 ce 6 e 0 /* 58 */
II (c, d, a, b , x[6], S43, 0xa 3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e 0811a 1);
II (a, b, c, d, x[4], S41, 0xf 7537 e82 /* 61 */
II (d, a, b, c); , x[11], S42, 0x BD 3 af 235); /* 62 */
II (c, d, a, b, x[2], S43, 0x 2 ad 7d 2 bb ); /* 63 */
II (b, c, d, a, x[9], S44, 0 xeb 86d 391); [0] = a;
estado[1] = b;
estado[2] = c;
estado[3] = d;< / p>
memset((unsigned char *)x, 0, sizeof(x));
}
Codificación nula estática (unsigned char * salida, UINT32 *entrada, unsigned int len)
{
Unsigned int i, j
for (i = 0, j = 0; j ltleni, j = 4) {
salida[j] = (carácter sin firmar)(entrada[I] amp; 0x ff);
salida[
j 1] = (carácter sin firmar) ((entrada[I] gt; gt8) amp; 0x ff
salida[j 2] = (carácter sin firmar) ((entrada[I] gt ; gt16); ); 0x ff);
salida[j 3] = (carácter sin firmar) ((entrada[I] gt; gt24) amp; 0x ff); >
}
Decodificación de vacío estático (UINT32 *salida, entrada *unsigned char, unsigned int len)
{
Ninguno Símbolo int i, j ;
for (i = 0, j = 0; j ltleni, j = 4)
salida[I]=((uint 32)entrada[j ])|(( (uint 32)entrada[j 1]) lt; lt8) |
(((uint 32)entrada[j 2]) lt; lt16)|(((uint 32) entrada[j 3] ) lt; lt24);
}
-
Sólo estos dos documentos. Cuando los use, agréguelos al proyecto o archivo MAKE e incluya md5.h al llamar. Para un ejemplo simple, ingrese una cadena y luego calcule su valor md5 de salida. La prueba pasa bajo VC6.0 y GCC4.4:
# include ltstdio.h gt
# include. ltstring.h gt
#Include "md5.h"
int main()
{
char tmp[128];
Resumen de caracteres sin firmar[16];
Contexto MD5_CTX;
scanf("s ", tmp);
MD5 init( amp; contexto);
actualización de MD 5 (amp; contexto, (carácter sin firmar*)tmp, strlen(tmp)); >
printf(" Valor MD 5: ");
for(int I = 0; i lt16; i)
{
printf( "02X ",digest[I]);
}
printf("\n");
Devuelve 0;
p>
}