Escribir programa de cifrado en lenguaje c
#include
#include "global.h"
#include "md5.h"
#definir S11 7
#definir S12 12
#definir S13 17
#definir S14 22
#definir S21 5
#definir S22 9
#definir S23 14
#definir S24 20
#definir S24 20p>
#definirS31 4
#definir S32 11
#definir S33 16
#definir S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static void MD5Transform PROTO_LIST (( UINT4 [ 4], carácter sin firmar
[64]));
codificación estática vacía PROTO_LIST
((carácter sin signo *, UINT4 *, int sin signo) );
static void Decodificar PROTO_LIST
((UINT4 *, unsigned char *, unsigned int));
static void MD5_memcpy PROTO_LIST ((POINTER, POINTER) , unsigned
int));
static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));
static unsigned char 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, 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
};
#define F(x, y, z) (((x) & (y))| ((~x) & (z )))
#define G( x, y, z) (((x) & (z)))| ((y) & (~z)))
#definir H(x, y, z) ((x) ^ (y) ^ (z))
#definir I(x, y, z) ((y) ^ ((x ) | (~z)))
#define ROTATE_ LEFT(x,
n) (((x) << (n)))| ((x) >> (32-(n))))
#definir FF(a, b, c, d, x , s, ac) { (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = GIRAR_ IZQUIERDA ((a), (s); )); (a) += (b);}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac);\
(a) = ROTATE_LEFT ((a), ( s)) ; \
(a) += (b); \
}
#definir HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac);\
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + ( UINT4)(ac);\
(a) = ROTATE_LEFT ((a), (s));
(a) += (b);
}
void MD5Init (contexto)
MD5_CTX *contexto
{
contexto->count[ 0] = contexto->recuento[1] = 0;
contexto->estado[0] = 0x67452301;
contexto->estado[1] = 0xefcdab89;
contexto->estado[2] = 0x98badcfe;
contexto->estado[3] = 0x10325476;
}
void MD5Update (contexto, entrada , inputLen)
MD5_CTX *context;
unsigned char *entrada
unsigned int inputLen
{
unsigned int i, index, partLen;
index = (unsigned int)((context-& gt;count[0] >>3) & 0x3F);
if ((context->count[0] += ((UINT4)inputLen << 3))< ((UINT4)inputLen << 3))
contexto->count[1]++;
contexto->count[1] += ((UINT4)inputLen <<< 29);
partLen = 64 - index;
if ( inputLen <= partLen)
{
MD5_memcpy((PUNTERO)&context->búfer[índice], (PUNTO)entrada, partLen);
MD5Transform (contexto->.state, contexto->búfer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (contexto-> estado, & input[i]);
index = 0;
}
else
i = 0;
MD5_memcpy((POINTER)&context->buffer[ index], (POINTER)&input[i],inputLen-i) ;
}
void MD5Final (resumen, contexto)
resumen de caracteres sin firmar[16 ];
MD5_CTX *context;
{
bits de caracteres sin firmar[8 ];
índice int sin signo, padLen;
p>
Codificar (bits, contexto->recuento, 8);
índice = (int sin signo)((contexto->recuento[0] >> 3 ) & 0x3f );
padLen = (índice < 56) ?(56 - índice): (120 - índice);
MD5Update (contexto, PADDING, padLen);
MD5Update (contexto, bits, 8);
Codificar (resumen, contexto->.state, 16);
MD5_memset ((POINTER)context, 0, sizeof (* contexto));
}
Transformación estática vacía MD5 (estado UINT4[4], bloque de caracteres sin firmar[64])
{
UINT4 a = estado [0], b = estado[1], c = estado[2], d = estado[3], x[16];
decodificar(x, bloque, 64) ;
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 */
FF (b, c, d, a, x[ 3 ], S14, 0xc1bdceee /* 4 */
FF (a, b, c, d, x[ 4 ]); , S11, 0xf57c0faf) ; /* 5 */
FF (d, a, b, c, x[ 5 ], S12, /* 6 */
); FF (c, d, a, b, x
[ 6], S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x[ 7], S14, 0xfd469501 /* 8 */
);FF (a, b, c, d, x[ 8], S11, 0x698098d8 /* 9 */
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x[ 10], S13, 0xffff5bb1); (b, c, d, a, x[11], S14, 0x895cd7be);/* 12 */
FF (a, b, c, d, x[12], S11, 0x6b901122) ; /* 13 */
FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
FF (c, d) , a, b, x[14], S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x[15], S14, 0x49b40821); */
/* Ronda 2*/
GG (a, b, c, d, x[ 1], S21, 0xf61e2562 /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc0404038e S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x) [ 11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa /* 20 */
);GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[ 10] , S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8 /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6 ) ; /* 25 */
GG (d, a, b, c, x[ 14], S22, 0xc33707d6); /* 26 */
GG (c, d) , a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); */
GG (a, b, c, d, x[ 13], S21, 0xa9e3e905 /* 29 */
/
GG); (d, a, b, c, x[ 2], S22, 0xfcefa3f8 /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9 ) ; /* 31 */
GG (b, c, d, a, x[ 12], S24, 0x8d2a4c8a) /* 3
2 */
/* Ronda 3*/
HH (a, b, c, d, x[ 5], S31, 0xfffa3942 /* 33 */< /); p>
HH (d, a, b, c, x[ 8], S32, 0x8771f681 /* 34 */
HH (c, d, a, b, x[ 11); ], S24, 0x8d2a4c8a); /* 34 */
HG (c, d, a, b, x[ 12], S24, 0x8d2a4c8a) b, x[ 11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[ 14], S34, 0xfde5380c /* 36 */
HH (a, b , c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60 /* 39 */
HH (b, c, d, a ,); x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6 /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3 ] , S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, /* 44 */
); HH (a, b, c, d, x[ 9], S31, 0xd9d4d039 /* 45 */
HH (d, a, b, c, x[ 12], S32, 0xe6db99e5); ); /* 46 */
HH (c, d, a, b, x[ 15], S33, 0x1fa27cf8); /* 47 */
HH (b , c, d, a, x[2], S34, 0xc4ac5665);/* 48 */
/* Ronda 4*/
II (a, b, c , d , x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97 /* 50 */
II (c, d, a, b, x[ 14], S43, 0xab9423a7 /* 51 */
II (b, c, d, a, x [ 5); ], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[ 12], S41, 0x655b59c3 /* 53 */
II (c, d, a, b, x[ 10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1 /* 56 */
<);p>II (a, b, c, d, x[ 8], S41, 0x6fa87e4f /* 57 */
II (d, a, b, c, x[ 15], S42); , 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314 /* 59 */
II ( b, c, d, a, x[ 13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[ 11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /
estado[0] += a;
estado[1] += b;
estado[2] += c;
estado[3] += d;
MD5_memset ((POINTER)x, 0, tamaño de (x));
}
vacío estático Codificar (salida, entrada, len)
static void Decodificar (salida, entrada, len)
UINT4 *salida;
carácter sin firmar *entrada; p>
unsigned int len;
{
unsigned int i, j;
para (i = 0, j = 0; j < len ; i++, j += 4)
salida[i] = ((UINT4)entrada[j])| (((UINT4)entrada[j+1]) < < 8) ( (UINT4 ) entrada[j+2]) << 16)| (((UINT4)entrada[j+3]) << 24);
}
estática void MD5_memcpy (salida, entrada, len)
Salida de PUNTERO;<
Entrada de PUNTERO;
int sin signo len;
{
unsigned int i;
for (i = 0; i < len; i++)
salida[i] = entrada[i];
}
static void MD5_memset (salida, valor, len)
salida de PUNTERO;
valor int;
int sin signo len;
p>
{
unsigned int i;
for (i = 0; i < len; i++)
((char *)salida) [i] = (char)valor;
}
#ifndef MD
#define MD 5
#endif<
p>#define TEST_BLOCK_LEN 1000
#define TEST_BLOCK_COUNT 1000
static void MDString PROTO_LIST ((char *));
static void MDPrint PROTO_LIST ((unsigned char [16]));
#define MD_CTX MD5_CTX
#define MDInit MD5Init
#define MDUpdate MD5Update
#define MDFinal MD5Final
int main (int argc, char *argv[])
{
int i;
if (argc > 1 )
{ MDString(argv[1]);
return ( 0);
}
}
MDString vacío estático (char *cadena)
{
contexto MD_CTX;
resumen de caracteres sin firmar[16];
sin firmar int len = strlen (cadena);
MDInit (& contexto);
MDUpdate (& contexto, cadena, len
MDFinal); , & contexto);
printf ("MD%d (\"%s\") = ", MD, cadena
MDPrint (resumen
);printf ("\n");
}
MDPrint vacío estático (resumen de caracteres sin firmar[16])
{
unsigned int i;
for (i = 0; i < 16; i++)
printf ("%02x", digest[i]);
}