md5.h

ice中间件 文件传输原代码 更新为服务形式

  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函数                                                              */
/************************************************************************/
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;
}



/************************************************************************/
/* 对称加解密算法函数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;