Cifrado de texto y código fuente de descifrado
-
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
Transformación estática vacía MD5 (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
};
#Definir F(x, y, z)(( (x)&(y) )|((~ x)&(z)))
#Definición G(x, y, z)(((x)&(z)) z))|((y)& (~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))))
#Definir FF(a, b, c, d, x, s, ac ) { \
( a) += F ((b), (c), (d))+(x)+(uint 32)(AC); s));\
(a)+=(b);\
}
#Definición GG(a, b, c, d, x , s, ac) { \
(a) += G ((b), (c), (d))+(x)+( uint 32)(AC);\
(a) = GIRAR_LEFT ((a), (s));\
(a)+=(b)
;\
}
#Definición HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d))+(x)+(uint 32)(AC);\
(a) = 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->recuento[0] = contexto->recuento[1]= 0;
Contexto-> >estado [0]= 0x 67452301
Contexto->estado[1]= 0x efcdab 89;
Contexto->estado[2]= 0x 98 cfe incorrecto ;
Context->;state[3]= 0x 10325476;
}
actualización void MD5(MD5_CTX *context, entrada de carácter sin firmar*, entrada de entero sin signo)
{
Unsigned int i, index, partLen
index = (unsigned int)((context-& gt; count [0]>>3)&0x3F) ;
if((Context->count[0]+=((uint 32)len de entrada<<3))
<((uint 32)len de entrada<<3) )
Contexto->count[1]++;
Contexto- >;count[1]+=((uint 32)input len & gt;& gt29) ;
part len = 64-index;
if(input len & gt; = partLen) {
memcpy((unsigned char * )& contexto->búfer[índice], (carácter sin firmar *)entrada, partLen);
MD5Transform( contexto->estado, contexto->búfer);
para (I = parte len;I+63<inputLeni += 64)
MD5Transform(context ->País&Input[I]);
Índice = 0;
}
Otro
I = 0 ;
memcpy((carácter sin firmar*)&context->búfer[índice],(sin firmar char*)&input[i],
input len-I);
}
void MD5Final(resumen de caracteres sin firmar[16], MD5_CTX * contexto)
{
bits de caracteres sin firmar[8];
Índice int sin signo, padLen
codificación(bits, contexto-> ; recuento, 8);
índice = (unsigned int)((context->count[0]>>3)&0x3f);
>
padLen =(índice <56)?(56 -índice):(120 -índice);
MD5Update (contexto, PADDING, padLen);
MD5Update ( contexto, bits, 8);
codificación(abstracto, contexto->; estado,
memset((unsigned char *)contexto, 0, tamaño de(* contexto) );
}
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 * /
FF (d, a, b, c, x[ 1], S12, 0x e 8 c 7 b 756); , b, x[ 2], S13, 0x 242070 db); /* 3 */
FF (b, c, d, a, x[ 3], S14, 0xc 1 BDC eee); /* 4 */
FF (a, b, c, d, x[ 4], S11, 0 xf 57 c 0 faf); (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); 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); /p>
FF (b, c, d, a, x[11], S14, 0x 895 CD 7 ser /* 12 */
FF (a, b , c,); d, x[12], S11, 0x6b 901122); /* 13 */
FF (d, a, b, c, x[13], S12, 0x FD 987193); */
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); /
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); /* 21 */
GG (d, a, b, c, x[10], S22, 0x 2441453);
*/
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 */
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); 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); /* 28 */
GG (a, b, c, d, x[13], S21, 0x a 9 e 3 e 905); */
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);/* 32 */
/*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); (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, 0xf 6bb 4b 60); /* 39 */
HH (b, c, d, a, x[10], S34, 0x antes de 70 */);
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); /* 46 */
HH (c, d, a, b, x[15], S33, 0x 1fa 27 cf 8);
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); /* 50 */
>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;
memset((unsigned char *)x, 0, sizeof(x));
}
Codificación vacía estática (unsigned char * Salida, UINT32 *Entrada, int sin signo len)
{
Int sin signo i,j;
for (i = 0, j = 0; j & ltleni++, j += 4) {
salida[j] = (carácter sin firmar)(entrada[I]&0x ff);
salida[j+ 1] =(carácter sin firmar) ((entrada[I]>>8)&0x ff);
salida[j+2] =(carácter sin signo)((entrada[ I]>>16);0x ff);
salida[j+3] = (carácter sin firmar)((entrada[I]>>24)&0x ff) ;
}
}
Decodificación vacía estática (UINT32 *salida, entrada char unsigned *, int len unsigned)
{
Int unsigned i, j
salida[ I]=((uint 32)entrada[j])|(((uint 32)entrada [j+1])& lt;& lt8) |
(((uint 32)entrada[j +2])<<16)|(((uint 32)entrada[j+3] )<<24);
}
>-
Sólo estos dos documentos. Cuando los use, agréguelos al proyecto o archivo MAKE e incluya md5.h al llamar. Como 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
. # incluir & ltstring.h & gt
#Include "md5.h"
int main()
{
char tmp [128];
Resumen de caracteres sin firmar[16];
Contexto MD5_CTX;
scanf("%s ", tmp);
p>
MD5 init(& contexto);
MD 5 actualización(& contexto, (unsigned char*)tmp, strlen(tmp));
MD5Final( resumen y contexto);
printf(" Valor MD 5:");
for(int I = 0;i<16;++i)
{
printf("%02X ",digest[I]);
}
printf(" \ n ");
Devuelve 0;
}