encry.c

abstract rtos

            D_ENCRYPT(r, l, (i - 2)); 
            D_ENCRYPT(l, r, (i - 4)); 
            D_ENCRYPT(r, l, (i - 6)); 
        }
    }
    l = (l >> 1) | (l << 31);
    r = (r >> 1) | (r << 31);
    
    l &= 0xffffffffL;
    r &= 0xffffffffL;

    FP(r, l);
    data[0] = l;
    data[1] = r;
    l = r = t = u = 0;
}


void des_ecb_encrypt(des_cblock *input, des_cblock *output, des_key_schedule ks, int encrypt)
{
    register DES_LONG l;
    register unsigned char *in, *out;
    DES_LONG ll[2];

    in = (unsigned char *)input;
    out = (unsigned char *)output;
    c2l(in, l);
    ll[0] = l;
    c2l(in, l);
    ll[1] = l;
    des_encrypt(ll, ks, encrypt);
    l = ll[0];
    l2c(l, out);
    l = ll[1];
    l2c(l, out);
    l = ll[0] = ll[1] = 0;
}

void DecryptPassword( char *szCipher, char *szClearText )
{
    unsigned char szTempBuf[80];
    short i;

    for ( i = 0; i < 80; i ++ )
    {
        szTempBuf[i] = 0x0;	
    }

    AscToBin( szTempBuf, 16, szCipher, 24);	

    des_set_key((des_cblock *) g_szKeyData, g_stPwdKey );	

    
    des_ecb_encrypt( (des_cblock *)szTempBuf, (des_cblock *)szClearText, g_stPwdKey, DES_DECRYPT );
    des_ecb_encrypt((des_cblock *)(szTempBuf + 8), (des_cblock *)(szClearText + 8), g_stPwdKey, DES_DECRYPT );

    szClearText[16] = 0x0;   
}

void EncryptPassword( char *szClearText, char *szCipher )
{
    unsigned char szTempBuf[80];
    short i;

    for ( i = 0; i < 80; i ++ )
    {
        szTempBuf[i] = 0x0;	
    }

    des_set_key( (des_cblock *)g_szKeyData, g_stPwdKey );	

    
    des_ecb_encrypt( (des_cblock *)szClearText, (des_cblock *)szTempBuf, g_stPwdKey, DES_ENCRYPT );
    des_ecb_encrypt( (des_cblock *)(szClearText + 8), (des_cblock *)(szTempBuf + 8), g_stPwdKey, DES_ENCRYPT );

    BinToAsc( szTempBuf, 16, szCipher, 24);	
    szCipher[24] = 0x0;   
}

unsigned long IsStringCipher( char *szInput )
{
    int i;
    char ucChar;

    for ( i = 0; i < 24; i ++ )
    {
        ucChar = (char)szInput[i];
        if ( ucChar < 0x21 || ucChar > 0x61 )
        {
            return 0;   
        }
    }

    
    if ( szInput[24] == 0x0 &&  		
            szInput[22] == 0x21 &&  	
            szInput[23] == 0x21 )
    {
        return 1;   
    }

    return 0;		
}


void Encrypt_data_with_key( unsigned char *szClearText, U32 ulClearTextLen
								, unsigned char * szCipher
								, unsigned char * key )
{
    U32 i;
    des_key_schedule stPwdKey;

    des_set_key( (des_cblock *)key, stPwdKey );	
    
    for ( i = 0; i < ulClearTextLen; i = i+8 )
    {
    
	    
	    des_ecb_encrypt( (des_cblock *)(szClearText+i), (des_cblock *)(szCipher+i), stPwdKey, DES_ENCRYPT );
    }
}



void Decrypt_data_with_key( unsigned char *szCipher, U32 ulClearTextLen
								, unsigned char * szClearText
								, unsigned char * key )
{
    U32 i;
    des_key_schedule stPwdKey;

    des_set_key( (des_cblock *)key, stPwdKey );	
    
    for ( i = 0; i < ulClearTextLen; i = i+8 )
    {
    
	    
	    des_ecb_encrypt( (des_cblock *)(szCipher+i), (des_cblock *)(szClearText+i), stPwdKey, DES_DECRYPT );
    }
}

#define ROUNDS 32
#define DELTA 0x9e3779b9 


void tea_encipher_new(const unsigned long *const v,unsigned long *const w,
   const unsigned long * const k , unsigned long rounds)
{
   register unsigned long       n=rounds,sum=0;
#if( CONDIF_LITTLE_ENDIAN == TRUE  || CONFIG_CPU_MIPS == TRUE)
   unsigned long       y,z;
   aos_memcpy(&y, (U8*)v, 4);
   aos_memcpy(&z, (U8*)v+4,4);
   y = AOS_HTONL(y);
   z = AOS_HTONL(z);

#else
   register unsigned long       y=AOS_HTONL(v[0]),z=AOS_HTONL(v[1]);
#endif


    while(n-->0)
    {
      y += (z << 4 ^ z >> 5) + z ^ sum + k[sum&3];
      sum += DELTA;
      z += (y << 4 ^ y >> 5) + y ^ sum + k[sum>>11 & 3];
    }
#if( CONDIF_LITTLE_ENDIAN == TRUE  || CONFIG_CPU_MIPS == TRUE)
    y = AOS_HTONL(y);
    z = AOS_HTONL(z);
    aos_memcpy((U8*)w, &y, 4);
    aos_memcpy((U8*)w+4, &z, 4);
#else
    w[0]=AOS_HTONL(y); w[1]=AOS_HTONL(z);
#endif
}

void tea_decipher_new(const unsigned long *const v,unsigned long *const w,
   const unsigned long * const k, unsigned long rounds)
{
    register unsigned long       sum=DELTA*rounds, n=rounds;
#if( CONDIF_LITTLE_ENDIAN == TRUE || CONFIG_CPU_MIPS == TRUE)
    unsigned long       y,z;
   
   aos_memcpy(&y, (U8*)v, 4);
   aos_memcpy(&z, (U8*)v+4,4);
   y = AOS_HTONL(y);
   z = AOS_HTONL(z);
#else
    register unsigned long       y=AOS_HTONL(v[0]),z=AOS_HTONL(v[1]);
#endif

    while(n-->0)
    {
      z -= (y << 4 ^ y >> 5) + y ^ sum + k[sum>>11 & 3];
      sum -= DELTA;
      y -= (z << 4 ^ z >> 5) + z ^ sum + k[sum&3];
    }
    
#if( CONDIF_LITTLE_ENDIAN == TRUE  || CONFIG_CPU_MIPS == TRUE)
    y = AOS_HTONL(y);
    z = AOS_HTONL(z);
    aos_memcpy((U8*)w, &y, 4);
    aos_memcpy((U8*)w+4, &z, 4);
#else
    w[0]=(y); w[1]=(z);
#endif
}


U32 tea_encrypt_fixedkey(U8 * InputBuf, U32 ulLen, U8 * OutputBuf)
{
	U32 key[4] = {15014,13102,18110,98476};
	U32 ulOffSet, i;

	ulOffSet = ulLen%8;
	if(ulOffSet)
	{
		return AOS_FAIL;
	}	
 
	for(i = 0; i < ulLen; i = i+8)
	{
		tea_encipher_new((U32*)(InputBuf+i), (U32*)(OutputBuf+i), key, 8);	
	}

	return AOS_SUCC;
}



U32 tea_decrypt_fixedkey(U8 * InputBuf, U32 ulLen, U8 * OutputBuf)
{
	U32 key[4] = {15014,13102,18110,98476};
	U32 ulOffSet, i, room;

    room = mem_obj_room(OutputBuf);
    if( ulLen > room )
    {
        AOS_ASSERT_FUNC( 0, aos_printf(0,"tea_decrypt_fixedkey:OutputBuf=0x%x,InputBuf=0x%x,ulLen=%u,room=%u", OutputBuf, InputBuf, ulLen, room) );
        
        aos_task_show_call_stack(0);
        return AOS_FAIL;
    }

	ulOffSet = ulLen%8;
	if(ulOffSet)
	{
		return AOS_FAIL;
	}	

	for(i = 0; i < ulLen; i = i+8)
	{
		tea_decipher_new((U32*)(InputBuf+i), (U32*)(OutputBuf+i), key, 8);	
	}

	return AOS_SUCC;
}



S8 * tea_encrypt_rapid_signal_msg(S8 * pszMsg, U32 ulMsgLen, U32 ulMpe, U32 * pulCiperLen)
{
	U32 ulTrueLen = 0;
	U32 ulOffSet = 0;
	S8 * pszSendMsg = NULL;

	if(NULL == pszMsg || NULL == pulCiperLen)
	{
		AOS_ASSERT(0);
		return NULL;
	}

	if(ulMsgLen%8)
	{
		ulOffSet = 8 - (ulMsgLen%8);
	}

	ulTrueLen = ulMsgLen + ulOffSet;

    pszSendMsg = (S8 *)aos_msg_alloc(ulMpe, ulTrueLen + 1);
    if(NULL == pszSendMsg)
    {
		AOS_ASSERT(0);
		return NULL;
    }

    pszSendMsg[0] = '\0';

	if(ulOffSet)
	{
    	aos_memset(pszSendMsg, ' ', ulOffSet);
	}

	aos_memcpy(pszSendMsg + ulOffSet, pszMsg, ulMsgLen);

	tea_encrypt_fixedkey(pszSendMsg, ulTrueLen, pszSendMsg);

	pszSendMsg[ulTrueLen] = '\0';

	*pulCiperLen = ulTrueLen;

	return pszSendMsg;
}

S8 * tea_decrypt_rapid_signal_msg(S8 * pszMsg, U32 ulMsgLen, U32 * pulCiperLen)
{
	S8 * pMsg = NULL;
    U32 i;

    if(NULL == pszMsg || NULL== pulCiperLen)
    {
    	AOS_ASSERT(0);
		return NULL;
    }

	if(ulMsgLen%8)
	{
		return NULL;
	}

	tea_decrypt_fixedkey(pszMsg, ulMsgLen, pszMsg);

    for(i = 0; i < ulMsgLen; i++)
    {
        pMsg = pszMsg + i;
        if(' ' != pMsg[0])
        {
            break;
        }
    }

	*pulCiperLen = ulMsgLen - i;

	return pMsg;
}