md5.h

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

    des_crypt( ctx->dsk, input, output );
}

int des3_set_2keys( des3_context *ctx, uint8 key1[8], uint8 key2[8] )
{
    int i;
    des_main_ks( ctx->esk     , key1 );
    des_main_ks( ctx->dsk + 32, key2 );

    for( i = 0; i < 32; i += 2 )
    {
        ctx->dsk[i     ] = ctx->esk[30 - i];
        ctx->dsk[i +  1] = ctx->esk[31 - i];

        ctx->esk[i + 32] = ctx->dsk[62 - i];
        ctx->esk[i + 33] = ctx->dsk[63 - i];

        ctx->esk[i + 64] = ctx->esk[     i];
        ctx->esk[i + 65] = ctx->esk[ 1 + i];

        ctx->dsk[i + 64] = ctx->dsk[     i];
        ctx->dsk[i + 65] = ctx->dsk[ 1 + i];
    }

    return  SUCCESS;
}

int des3_set_3keys( des3_context *ctx, uint8 key1[8], uint8 key2[8],
                                       uint8 key3[8] )
{
    int i;
    des_main_ks( ctx->esk     , key1 );
    des_main_ks( ctx->dsk + 32, key2 );
    des_main_ks( ctx->esk + 64, key3 );

    for( i = 0; i < 32; i += 2 )
    {
        ctx->dsk[i     ] = ctx->esk[94 - i];
        ctx->dsk[i +  1] = ctx->esk[95 - i];

        ctx->esk[i + 32] = ctx->dsk[62 - i];
        ctx->esk[i + 33] = ctx->dsk[63 - i];

        ctx->dsk[i + 64] = ctx->esk[30 - i];
        ctx->dsk[i + 65] = ctx->esk[31 - i];
    }

    return  SUCCESS;
}

void des3_crypt( uint32 SK[96], uint8 input[8], uint8 output[8] )
{
    uint32 X, Y, T;

    GET_UINT32( X, input, 0 );
    GET_UINT32( Y, input, 4 );

    DES_IP( X, Y );

    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );

    DES_ROUND( X, Y );  DES_ROUND( Y, X );
    DES_ROUND( X, Y );  DES_ROUND( Y, X );
    DES_ROUND( X, Y );  DES_ROUND( Y, X );
    DES_ROUND( X, Y );  DES_ROUND( Y, X );
    DES_ROUND( X, Y );  DES_ROUND( Y, X );
    DES_ROUND( X, Y );  DES_ROUND( Y, X );
    DES_ROUND( X, Y );  DES_ROUND( Y, X );
    DES_ROUND( X, Y );  DES_ROUND( Y, X );

    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );
    DES_ROUND( Y, X );  DES_ROUND( X, Y );

    DES_FP( Y, X );

    PUT_UINT32( Y, output, 0 );
    PUT_UINT32( X, output, 4 );
}

void des3_encrypt( des3_context *ctx, uint8 input[8], uint8 output[8] )
{
    des3_crypt( ctx->esk, input, output );
}

void des3_decrypt( des3_context *ctx, uint8 input[8], uint8 output[8] )
{
    des3_crypt( ctx->dsk, input, output );
}


int DESEncrypt(OUT unsigned char *Out,IN unsigned char *In,IN unsigned long datalen,IN unsigned char *KeyData)
{
	des_context  DESctx;
	long	i,j;
	unsigned long fill_len = 0;
	unsigned char temp1[8] = {0};
	unsigned char temp2[8] = {0};
	
	if (datalen <= 0)
		return PARAMETER;
	if( !( Out && In && KeyData   ) )
		return PARAMETER;
	
		
	if(datalen>8)
	{
		memcpy(DES3_keys[0],KeyData,8);
		des_set_key( &DESctx,DES3_keys[0]);
		for(i=0,j=datalen/8; i<j; ++i,Out+=8,In+=8)
			des_encrypt( &DESctx, In, Out);
		
		//处理后几个字节，也就是进行填充
		fill_len = datalen/8*8 + datalen%8 - 8;
		memmove(temp1,Out-8+datalen%8, 8-datalen%8);
		memmove(temp1+8-datalen%8,In,datalen%8);
		des_encrypt( &DESctx,temp1,Out-8+datalen%8 );
	}
	else
	{
		memcpy(DES3_keys[0],KeyData,8);
		des_set_key( &DESctx,DES3_keys[0]);
		des_encrypt( &DESctx, In, Out);
//		des_encrypt( &DESctx, vi, temp1);
//		for(fill_len=0; fill_len<datalen;fill_len++)
//			Out[fill_len] = temp1[fill_len]^In[fill_len];
	}
	
	return SUCCESS;
}


int DESDecrypt(OUT unsigned char *Out,IN unsigned char *In,IN unsigned long datalen,IN unsigned char *KeyData)
{
	des_context  DESctx;
	long	i,j;
	unsigned long fill_len = 0;
	unsigned char temp1[8] = {0};
	unsigned char temp2[8] = {0};
	
	if (datalen <= 0)
		return PARAMETER;
	if( !( Out && In && KeyData   ) )
		return PARAMETER;
	
	
	if(datalen>8)
	{
		memcpy(DES3_keys[0],KeyData,8);
		des_set_key( &DESctx,DES3_keys[0]);
		for(i=0,j=datalen/8-1; i<j; ++i,Out+=8,In+=8)
			des_decrypt( &DESctx, In, Out);
		
		//处理后几个字节，也就是进行填充
		memcpy(temp1,In+datalen%8,8);
		des_decrypt( &DESctx,temp1,temp2);
		memcpy(Out+8,temp2+8-datalen%8,datalen%8);
		
		memcpy(temp1,In,datalen%8);
		memcpy(temp1+datalen%8,temp2,8-datalen%8);
		des_decrypt( &DESctx,temp1,temp2);
		memcpy(Out,temp2,8);
	}
	else
	{
		memcpy(DES3_keys[0],KeyData,8);
		des_set_key( &DESctx,DES3_keys[0]);
//		des_encrypt( &DESctx, vi, temp1);
			des_decrypt( &DESctx, In, Out);
//		for(fill_len=0; fill_len<datalen;fill_len++)
//			Out[fill_len] = temp1[fill_len]^In[fill_len];
	}
	
	return SUCCESS;
}


int DES3Encrypt(OUT unsigned char *Out,IN unsigned char *In,IN unsigned long datalen,IN unsigned char *KeyData)
{
	des3_context DES3ctx;
	long	i,j;
	unsigned long fill_len = 0;
	unsigned char temp1[8] = {0};
	unsigned char temp2[8] = {0};
	
	if (datalen <= 0)
		return PARAMETER;
	if( !( Out && In && KeyData   ) )
		return PARAMETER;
	

	if(datalen>8)
	{
		memcpy(DES3_keys[0],KeyData,8);
		memcpy(DES3_keys[1],KeyData+8,8);
		des3_set_2keys( &DES3ctx, DES3_keys[0],DES3_keys[1] );
		for(i=0,j=datalen/8; i<j; ++i,Out+=8,In+=8)
			des3_encrypt( &DES3ctx, In, Out );
		//处理后几个字节，也就是进行填充
		fill_len = datalen/8*8 + datalen%8 - 8;
		memmove(temp1,Out-8+datalen%8, 8-datalen%8);
		memmove(temp1+8-datalen%8,In,datalen%8);
		des3_encrypt( &DES3ctx,temp1,Out-8+datalen%8 );
	}
	else
	{
		memcpy(DES3_keys[0],KeyData,8);
		memcpy(DES3_keys[1],KeyData+8,8);
		des3_set_2keys( &DES3ctx, DES3_keys[0],DES3_keys[1] );
		des3_encrypt( &DES3ctx, vi, temp1);
		for(fill_len=0; fill_len<datalen;fill_len++)
			Out[fill_len] = temp1[fill_len]^In[fill_len];
	}
	
	return SUCCESS;
}


int DES3Decrypt(OUT unsigned char *Out,IN unsigned char *In,IN unsigned long datalen,IN unsigned char *KeyData)
{
	des3_context DES3ctx;
	long	i,j;
	unsigned long fill_len = 0;
	unsigned char temp1[8] = {0};
	unsigned char temp2[8] = {0};
	
	if (datalen <= 0)
		return PARAMETER;
	if( !( Out && In && KeyData   ) )
		return PARAMETER;
	
	
	if(datalen>8)
	{
		memcpy(DES3_keys[0],KeyData,8);
		memcpy(DES3_keys[1],KeyData+8,8);
		des3_set_2keys( &DES3ctx, DES3_keys[0],DES3_keys[1] );
		for(i=0,j=datalen/8-1; i<j; ++i,Out+=8,In+=8)
			des3_decrypt( &DES3ctx, In, Out );
		//处理后几个字节，也就是进行填充
		memcpy(temp1,In+datalen%8,8);
		des3_decrypt( &DES3ctx,temp1,temp2);
		memcpy(Out+8,temp2+8-datalen%8,datalen%8);
		
		memcpy(temp1,In,datalen%8);
		memcpy(temp1+datalen%8,temp2,8-datalen%8);
		des3_decrypt( &DES3ctx,temp1,temp2);
		memcpy(Out,temp2,8);
	}
	else
	{
		memcpy(DES3_keys[0],KeyData,8);
		memcpy(DES3_keys[1],KeyData+8,8);
		des3_set_2keys( &DES3ctx, DES3_keys[0],DES3_keys[1] );
		des3_encrypt( &DES3ctx, vi, temp1);
		for(fill_len=0; fill_len<datalen;fill_len++)
			Out[fill_len] = temp1[fill_len]^In[fill_len];
	}
	
	return SUCCESS;
}


/************************************************************************/
/* 产生随机数接口                                                       */
/************************************************************************/
/************************************************************************/
/* 产生随机的整数                                                       */
/************************************************************************/
void genrandinteruse (unsigned long * RandStr, unsigned long StrLen)
{
	unsigned long i;
	
	const unsigned long a = 65539;
	const unsigned long b = 65539; 
	
	unsigned long seed0;
	unsigned long seed1;
	
	srand( (unsigned)time( NULL ) );
	
	seed0 = rand();
	seed1 = rand();
	
	for(i=0; i<StrLen; i++)
	{
		RandStr[i] = a * seed1 + b * seed0 ;
		seed0 = seed1;
		seed1 =  RandStr[i];
	}	
}     

/************************************************************************/
/* 产生随机的数据                                                       */
/************************************************************************/
void R_memset (POINTER output,  int value,  unsigned int len)  
{
	if (len)
		memset (output, value, len);
}

void R_memcpy (	POINTER output,                                           
				POINTER input,                                            
				unsigned int len)
{
	if (len)
		memcpy (output, input, len);
}

int R_memcmp (	POINTER firstBlock, 
				POINTER secondBlock,
				unsigned int len)
{
	if (len)
		return (memcmp (firstBlock, secondBlock, len));
	else
		return (0);
}

void InitRandomStruct (R_RANDOM_STRUCT *randomStruct)
{
	
	R_memset ((POINTER)randomStruct, 0, sizeof (*randomStruct));
	genrandinteruse((UINT4 *)&randomStruct->state, 4);
	
}

int R_RandomInit (R_RANDOM_STRUCT *randomStruct)
{
  randomStruct->bytesNeeded = RANDOM_BYTES_NEEDED;
  R_memset ((POINTER)randomStruct->state, 0, sizeof (randomStruct->state));
  randomStruct->outputAvailable = 0;
  
  return (0);
}

int R_RandomUpdate (R_RANDOM_STRUCT *randomStruct, unsigned char *block, unsigned int blockLen)                       
{
  MD5_CTX context;
  unsigned char digest[16];
  unsigned int i, x;
  
  MD5Init (&context);
  MD5Update (&context, block, blockLen);
  MD5Final (digest, &context);

  x = 0;
  for (i = 0; i < 16; i++) {
    x += randomStruct->state[15-i] + digest[15-i];
    randomStruct->state[15-i] = (unsigned char)x;
    x >>= 8;
  }
  
  if (randomStruct->bytesNeeded < blockLen)
    randomStruct->bytesNeeded = 0;
  else
    randomStruct->bytesNeeded -= blockLen;
  
  R_memset ((POINTER)digest, 0, sizeof (digest));
  x = 0;
  
  return (0);
}

int R_GetRandomBytesNeeded (unsigned int *bytesNeeded, R_RANDOM_STRUCT *randomStruct)      
{
  *bytesNeeded = randomStruct->bytesNeeded;
  
  return (0);
}


int R_GenerateBytes (unsigned char *block, unsigned int blockLen, R_RANDOM_STRUCT *randomStruct)                 
{
  MD5_CTX context;
  unsigned int available, i;
  
  if (randomStruct->bytesNeeded)
    return (RE_NEED_RANDOM);
  
  available = randomStruct->outputAvailable;
  
  while (blockLen > available) {
    R_memcpy
      ((POINTER)block, (POINTER)&randomStruct->output[16-available],
       available);
    block += available;
    blockLen -= available;

    MD5Init (&context);
    MD5Update (&context, randomStruct->state, 16);
    MD5Final (randomStruct->output, &context);
    available = 16;

    for (i = 0; i < 16; i++)
      if (randomStruct->state[15-i]++)
        break;
  }

  R_memcpy 
    ((POINTER)block, (POINTER)&randomStruct->output[16-available], blockLen);
  randomStruct->outputAvailable = available - blockLen;

  return (0);
}

void R_RandomFinal (R_RANDOM_STRUCT *randomStruct)
{
  R_memset ((POINTER)randomStruct, 0, sizeof (*randomStruct));
}

/************************************************************************/
/* 非对称算法函数接口RSA                                                */
/************************************************************************/
/************************************************************************/
/* RSA结构定义                                                          */