?? md5.h
字號(hào):
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}
void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
{
unsigned int i, index, partLen;
index = (unsigned int)((context->count[0] >> 3) & 0x3F);
if ((context->count[0] += ((UINT4)inputLen << 3))
< ((UINT4)inputLen << 3))
context->count[1]++;
context->count[1] += ((UINT4)inputLen >> 29);
partLen = 64 - index;
if (inputLen >= partLen) {
MD5_memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
MD5Transform (context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (context->state, &input[i]);
index = 0;
}
else
i = 0;
MD5_memcpy ((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i);
}
void MD5Final (unsigned char digest[16], MD5_CTX *context)
{
unsigned char bits[8];
unsigned int index, padLen;
Encode (bits, context->count, 8);
index = (unsigned int)((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
MD5Update (context, PADDING, padLen);
MD5Update (context, bits, 8);
Encode (digest, context->state, 16);
MD5_memset ((POINTER)context, 0, sizeof (*context));
}
int MD5(IN unsigned char *DataIn,IN unsigned int DataLen, OUT unsigned char DataOut[16])
{
MD5_CTX context;
unsigned char data[MD5_BLOCK_SIZE];
memset(data,0,MD5_BLOCK_SIZE);
MD5Init (&context);
while(DataLen>=0)
{
if(DataLen<MD5_BLOCK_SIZE)
{
MD5Update (&context, DataIn, DataLen);
break;
}
else
{ memcpy(data,DataIn,MD5_BLOCK_SIZE);
MD5Update (&context, DataIn, MD5_BLOCK_SIZE);
DataIn += MD5_BLOCK_SIZE;
DataLen -=MD5_BLOCK_SIZE;
}
}
MD5Final (DataOut, &context);
return SUCCESS;
}
/************************************************************************/
/*SHA1函數(shù) */
/************************************************************************/
void SHA1Transform(unsigned long state[5], unsigned char buffer[64])
{
unsigned long a, b, c, d, e;
typedef union {
unsigned char c[64];
unsigned long l[16];
} CHAR64LONG16;
CHAR64LONG16* block;
//*#ifdef SHA1HANDSOFF
static unsigned char workspace[64];
block = (CHAR64LONG16*)workspace;
memcpy(block, buffer, 64);
//#else
block = (CHAR64LONG16*)buffer;
//#endif
/* Copy context->state[] to working vars */
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
/* 4 rounds of 20 operations each. Loop unrolled. */
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
/* Add the working vars back into context.state[] */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
/* Wipe variables */
a = b = c = d = e = 0;
}
/* SHA1Init - Initialize new context */
void SHA1Init(SHA1_CTX* context)
{
/* SHA1 initialization constants */
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
context->state[4] = 0xC3D2E1F0;
context->count[0] = context->count[1] = 0;
}
/* Run your data through this. */
void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len)
{
unsigned int i, j;
j = (context->count[0] >> 3) & 63;
if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
context->count[1] += (len >> 29);
if ((j + len) > 63) {
memcpy(&context->buffer[j], data, (i = 64-j));
SHA1Transform(context->state, context->buffer);
for ( ; i + 63 < len; i += 64) {
SHA1Transform(context->state, &data[i]);
}
j = 0;
}
else i = 0;
memcpy(&context->buffer[j], &data[i], len - i);
}
/* Add padding and return the message digest. */
void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
{
unsigned long i, j;
unsigned char finalcount[8];
for (i = 0; i < 8; i++) {
finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
}
SHA1Update(context, (unsigned char *)"\200", 1);
while ((context->count[0] & 504) != 448) {
SHA1Update(context, (unsigned char *)"\0", 1);
}
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
for (i = 0; i < 20; i++) {
digest[i] = (unsigned char)
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
}
/* Wipe variables */
i = j = 0;
memset(context->buffer, 0, 64);
memset(context->state, 0, 20);
memset(context->count, 0, 8);
memset(&finalcount, 0, 8);
// #ifdef SHA1HANDSOFF /* make SHA1Transform overwrite it's own static vars */
SHA1Transform(context->state, context->buffer);
// #endif
}
int SHA1(IN unsigned char *DataIn,IN unsigned long DataLen, OUT unsigned char DataOut[20])
{
SHA1_CTX context;
unsigned char data[SHA1_BLOCK_SIZE];
memset(data,0,SHA1_BLOCK_SIZE);
SHA1Init(&context);
while(DataLen>=0)
{
if(DataLen<SHA1_BLOCK_SIZE)
{
SHA1Update(&context, DataIn, DataLen);
break;
}
else
{ memcpy(data,DataIn,SHA1_BLOCK_SIZE);
SHA1Update(&context, data, SHA1_BLOCK_SIZE);
DataIn += SHA1_BLOCK_SIZE;
DataLen -=SHA1_BLOCK_SIZE;
}
}
SHA1Final(DataOut, &context);
return SUCCESS;
}
/************************************************************************/
/* 對(duì)稱加解密算法函數(shù)IDEA、DES、3DES、RC2、RC4 */
/************************************************************************/
/************************************************************************/
/* 加密算法中的向量定義 */
/************************************************************************/
unsigned char vi[8] = {0x84,0xA1,0x2D,0x8B,0xB3,0xFB,0x1A,0xA0};
/************************************************************************/
/* IDEA定義 */
/************************************************************************/
#define mulMod 0x10001
#define ones 0xFFFF
#define TRUE 1
#define FALSE 0
#define nomode 0
#define ecb 1
#define eol 0x100
#define colon 0x101
#define error 0x102
#define nofChar ('~' - '!' +1)
#define maxBufLen (Idea_dataSize * 1024)
Idea_UserKey userKey;
Idea_Key key;
int optEncrypt = FALSE;
int optDecrypt = FALSE;
#define AddInv(x) (-x & ones)
/************************************************************************/
/* IDEA算法 */
/************************************************************************/
#define Mul(a, b) \
if (a == 0) a = mulMod - b; \
else if (b == 0) a = mulMod - a; \
else { \
a *= b; \
if ((a & ones) >= (b = a >> 16)) a -= b; \
else a += mulMod - b; \
}
void Idea_Crypt (Idea_Data dataIn, Idea_Data dataOut, Idea_Key key)
{
register u_int32 x0, x1, x2, x3, t0, t1, t2;
int round;
x0 = (u_int32)*dataIn++; x1 = (u_int32)*dataIn++;
x2 = (u_int32)*dataIn++; x3 = (u_int32)*dataIn;
for (round = Idea_nofRound; round > 0; round--) {
t1 = (u_int32)*key++;
x1 += (u_int32)*key++;
x2 += (u_int32)*key++; x2 &= ones;
t2 = (u_int32)*key++;
Mul(x0, t1); x0 &= ones;
Mul(x3, t2);
t0 = (u_int32)*key++;
t1 = x0 ^ x2;
Mul(t0, t1); t0 &= ones;
t1 = (u_int32)*key++;
t2 = ( (x1 ^ x3) + t0 ) & ones ;
Mul(t1, t2); t1 &= ones;
t0 += t1;
x0 ^= t1; x3 ^= t0; x3 &= ones;
t0 ^= x1; x1 = x2 ^ t1; x2 = t0;
}
t0 = (u_int32)*key++;
Mul(x0, t0);
*dataOut++ = (u_int16)(x0 & ones);
*dataOut++ = (u_int16)((u_int32)*key++ + (x2 & ones));
*dataOut++ = (u_int16)((u_int32)*key++ + (x1 & ones));
t0 = (u_int32)*key;
Mul(x3, t0);
*dataOut = (u_int16)(x3 & ones);
}
static u_int16 MulInv (u_int16 x)
{
register int32 n1, n2, N, a1, a2, b1, b2;
if (x <= 1) return x;
n1 = N = (int32)x; n2 = mulMod;
a1 = b2 = 1; a2 = b1 = 0;
do {
while ((n1 & 1) == 0) {
if (a1 & 1) {
if (a1 < 0) { a1 += mulMod; b1 -= N; }
else { a1 -= mulMod; b1 += N; }
}
n1 >>= 1; a1 >>= 1; b1 >>= 1;
}
if (n1 < n2)
do {
n2 -= n1; a2 -= a1; b2 -= b1;
if (n2 == 0) return (u_int16)(a1 < 0 ? a1 + mulMod : a1);
while ((n2 & 1) == 0) {
if (a2 & 1) {
if (a2 < 0) { a2 += mulMod; b2 -= N; }
else { a2 -= mulMod; b2 += N; }
}
n2 >>= 1; a2 >>= 1; b2 >>= 1;
}
} while (n1 <= n2);
n1 -= n2; a1 -= a2; b1 -= b2;
} while (n1);
return (u_int16)(a2 < 0 ? a2 + mulMod : a2);
}
void Idea_InvertKey (Idea_Key key, Idea_Key invKey)
{
register u_int16 t, *in, *out;
register int lo, hi, i;
in = key; out = invKey;
lo = 0; hi = 6 * Idea_nofRound;
t = MulInv(in[lo]); out[lo++] = MulInv(in[hi]); out[hi++] = t;
t = AddInv(in[lo]); out[lo++] = AddInv(in[hi]); out[hi++] = t;
t = AddInv(in[lo]); out[lo++] = AddInv(in[hi]); out[hi++] = t;
t = MulInv(in[lo]); out[lo++] = MulInv(in[hi]); out[hi] = t;
for (i = (Idea_nofRound - 1) / 2 ; i != 0 ; i --) {
t = in[lo]; out[lo++] = in[hi -= 5]; out[hi ++] = t;
t = in[lo]; out[lo++] = in[hi]; out[hi] = t;
t = MulInv(in[lo]); out[lo++] = MulInv(in[hi -= 5]); out[hi++] = t;
t = AddInv(in[lo]); out[lo++] = AddInv(in[++hi]); out[hi--] = t;
t = AddInv(in[lo]); out[lo++] = AddInv(in[hi]); out[hi++] = t;
t = MulInv(in[lo]); out[lo++] = MulInv(in[++hi]); out[hi] = t;
}
#if (Idea_nofRound % 2 == 0)
t = in[lo]; out[lo++] = in[hi -= 5]; out[hi++] = t;
t = in[lo]; out[lo++] = in[hi]; out[hi] = t;
out[lo] = MulInv(in[lo]); lo++;
t = AddInv(in[lo]); out[lo] = AddInv(in[lo + 1]); lo++; out[lo++] = t;
out[lo] = MulInv(in[lo]);
#else
out[lo] = in[lo]; lo++;
out[lo] = in[lo];
#endif
}
void Idea_ExpandUserKey (Idea_UserKey userKey, Idea_Key key)
{
register int i;
#if (Idea_keyLen <= Idea_userKeyLen)
for (i = 0; i < Idea_keyLen; i++) key[i] = userKey[i];
#else
for (i = 0; i < Idea_userKeyLen; i++) key[i] = userKey[i];
for (i = Idea_userKeyLen; i < Idea_keyLen; i++)
if ((i & 7) < 6)
key[i] = (key[i - 7] & 127) << 9 | key[i - 6] >> 7;
else if ((i & 7) == 6)
key[i] = (key[i - 7] & 127) << 9 | key[i - 14] >> 7;
else
key[i] = (key[i - 15] & 127) << 9 | key[i - 14] >> 7;
#endif
}
u_int32 CharToInt(char ch)
{
if ('!' <= ch && ch <= '~') return ch - '!';
else if (ch == '\0') return eol;
else return error;
}
void ReadKeyString(char *str,int klength)
{
int i;
u_int32 val;
int count;
for ( count = 0; count < klength; count++ ) {
val = CharToInt(*str++);
for (i = Idea_userKeyLen - 1; i >= 0; i--) {
val += (u_int32)userKey[i] * nofChar;
userKey[i] = (u_int16)(val & 0xFFFF);
val >>= 16;
}
}
}
int IDEAEncrypt(IN char *in,OUT char *out,IN long length,
IN char *en_key)
{
int i;
long pos = 0;
char *inPtr;
char *outPtr;
long en_len;
u_int16 h;
Idea_Data data;
char mod_key[8];
int count;
for ( count = 0; count < 8; count++ )
mod_key[count] = '8';
for (i = Idea_userKeyLen - 1; i >= 0 ; i--)
userKey[i] = 0;
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號(hào)
Ctrl + =
減小字號(hào)
Ctrl + -