utilities.c

md5算法加密程序,vc编写,非常实用,可以学习,可以加入工程项目中

//------------------------------------------------------------------------------
//
//  Project:      TelenComm BlueTooth
//
//  File name:    Utilities.c
//
//  Author:       Charles Liu
//
//  Created:      10/8/2000
//
//  Description:
//
//
//  Copyright (c) 2000 TelenComm Inc. All rights reserved.
//
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
//  Includes
//
//------------------------------------------------------------------------------
#include "Common.h"
#include "math.h"
//------------------------------------------------------------------------------
//
//  Conastants
//
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
//  Defines
//
//------------------------------------------------------------------------------
#define HA_OFFSET_TO_LOWER              ('a' - 'A')

//------------------------------------------------------------------------------
//
//  Macros
//
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
//  Global Variables
//
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Local Variables
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
//  Local Functions
//
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
//  Global funnctions
//
//------------------------------------------------------------------------------
void UT_SkipBlanks(char **p)
{
  while (**p == ' ')
    (*p)++;
}
//------------------------------------------------------------------------------
bool UT_CharToHex(char **p, uint8 *pValue)
{
  UT_SkipBlanks(p);

  if ( ((**p)<= '9' && (**p)>= '0') ||
    ((**p)<= 'f' && (**p)>= 'a') ||
    ((**p)<= 'F' && (**p)>= 'A') )
  {
    if (**p >= 'a')
      *pValue = (**p) - 'a' + 10;
    else if (**p >= 'A')
      *pValue = (**p) - 'A' + 10;
    else
      *pValue = (**p) - '0';

    (*p)++;
    return true;
  }
  return false;
}
//------------------------------------------------------------------------------

bool UT_StrToUint8(char **p, uint8 *pValue)
{
  uint8  Value;

  if(UT_CharToHex(p,&Value)==false)
     return false;

  *pValue= Value << 4;
  if(UT_CharToHex(p,&Value)==false)
    return false;

  *pValue |= Value;

  return true;

}
//------------------------------------------------------------------------------

bool UT_StrToUint16(char **p, uint16 *pValue)
{
  uint8  Value;

  if(UT_StrToUint8(p,&Value)==false)
    return false;

  *pValue= Value << 8;
  if(UT_StrToUint8(p,&Value)==false)
    return false;

  *pValue |= Value;

  return true;
}
//------------------------------------------------------------------------------

bool UT_StrToUint32(char **p, uint32 *pValue)
{
  uint16  Value;

  if(UT_StrToUint16(p,&Value)==false)
    return false;

  *pValue= Value << 16;
  if(UT_StrToUint16(p,&Value)==false)
    return false;

  *pValue |= Value;

  return true;
}

//------------------------------------------------------------------------------
bool UT_StrToUint8xN(char **p, uint8 *pValue, uint16 N)
{
  int i;

  for(i=0;i<N;i++)
  {
    if(UT_StrToUint8(p,pValue+i)==false)
      return false;
  }
  return true;
}
//------------------------------------------------------------------------------
bool UT_StrToUint8xN_Reverse(char **p, uint8 *pValue, uint16 N)
{
  int i;

  for(i=0;i<N;i++)
  {
    if(UT_StrToUint8(p,pValue+N-i-1)==false)
      return false;
  }
  return true;
}
//------------------------------------------------------------------------------
void UT_Uint8ToHex(uint8 *p, char **ppStr)
{
  uint8 Lo,Hi;

  Lo= (*p) & 0x0F;
  Hi= (*p) >> 4;

  if( Hi < 0x0A)
    **ppStr = Hi+'0';
  else
    **ppStr = Hi+'a'-0x0A;

  (*ppStr)++;

  if( Lo < 0x0A)
    **ppStr = Lo+'0';
  else
    **ppStr = Lo+'a'-0x0A;

  (*ppStr)++;

}
//------------------------------------------------------------------------------
void UT_Uint8xNToHex(uint8 *p, char **ppStr, uint16 N, char Seperator)
{
   int i;

   for(i=0;i<N;i++)
   {
     UT_Uint8ToHex(p,ppStr);
     if(Seperator != 0)
     {
       **ppStr=Seperator;
       (*ppStr)++;
     }
     p++;
   }
}
//------------------------------------------------------------------------------
void UT_Uint8xNToHex_Reverse(uint8 *p, char **ppStr, uint16 N,char Seperator)
{
   int i;

   p=p+N-1;

   for(i=0;i<N;i++)
   {
     UT_Uint8ToHex(p,ppStr);
     if(Seperator != 0)
     {
       **ppStr=Seperator;
       (*ppStr)++;
     }
     p--;
   }
}

//------------------------------------------------------------------------------
void UT_NumToIntStr(uint32 Value, char **ppStr, uint16 Num)
{
  int i;
  uint32 Q, D, N;

  N=Value;
  D=1;
  for(i=0;i<Num;i++)
    D=10*D;

  for(i=Num;i>=0;i--)
  {
     Q= N/D;
     **ppStr = Q+'0';
     (*ppStr)++;
     N= N- Q * D;
     D= D/10;
  }
}
//------------------------------------------------------------------------------
uint32 UT_GetInt(char **p, int DefaultValue)
{
  uint32 Value = 0;
  bool   UseDefault;

  UseDefault = true;
  UT_SkipBlanks(p);

  while ( ((**p)<= '9' && (**p)>= '0') )
  {
    Value = Value * 10 + (**p) - '0';
    UseDefault = false;
    (*p)++;
  }

  if (UseDefault)
    return DefaultValue;
  else
    return Value;
}
//------------------------------------------------------------------------------
int UT_GetSignedInt(char **p, int DefaultValue)
{
  int    Value = 0;
  bool   UseDefault;
  bool   NegativeNum = false;

  UseDefault = true;
  UT_SkipBlanks(p);

  if ( (**p) == '-')
  {
  	NegativeNum = true;
  	(*p)++;
  }
  while ( ((**p)<= '9' && (**p)>= '0') )
  {
    Value = Value * 10 + (**p) - '0';
    UseDefault = false;
    (*p)++;
  }

  if (UseDefault)
    return DefaultValue;
  else
    return ((NegativeNum == false)? Value : -Value);
}
//------------------------------------------------------------------------------

bool UT_GetBdAddr(char **p, tBdAddr *BdAddr)
{
  uint32 Value = 0;
  int    i, j;

  BdAddr->Byte[0] = 0;
  BdAddr->Byte[1] = 0;
  BdAddr->Byte[2] = 0;
  BdAddr->Byte[3] = 0;
  BdAddr->Byte[4] = 0;
  BdAddr->Byte[5] = 0;

  UT_SkipBlanks(p);

  i = 0;
  j = 5;

  while ( ((**p)<= '9' && (**p)>= '0') ||
          ((**p)<= 'f' && (**p)>= 'a') ||
          ((**p)<= 'F' && (**p)>= 'A') )
  {
    if (i < 12)
    {
      if (**p >= 'a')
        Value = Value * 16 + (**p) - 'a' + 10;
      else if (**p >= 'A')
        Value = Value * 16 + (**p) - 'A' + 10;
      else
        Value = Value * 16 + (**p) - '0';

      if (i & 1) // Odd
      {
        BdAddr->Byte[j--] = Value;

        Value = 0;
      }
    }
    i++;

    (*p)++;
  }

  if (i == 12)
    return true; // Good syntax
  else
    return false;
}


bool UT_GetBdAddrRev(char **p, tBdAddr *BdAddr)
{
  uint32 Value = 0;
  int    i, j;

  BdAddr->Byte[0] = 0;
  BdAddr->Byte[1] = 0;
  BdAddr->Byte[2] = 0;
  BdAddr->Byte[3] = 0;
  BdAddr->Byte[4] = 0;
  BdAddr->Byte[5] = 0;

  UT_SkipBlanks(p);

  i = 0;
  j = 0;

  while ( ((**p)<= '9' && (**p)>= '0') ||
          ((**p)<= 'f' && (**p)>= 'a') ||
          ((**p)<= 'F' && (**p)>= 'A') )
  {
    if (i < 12)
    {
      if (**p >= 'a')
        Value = Value * 16 + (**p) - 'a' + 10;
      else if (**p >= 'A')
        Value = Value * 16 + (**p) - 'A' + 10;
      else
        Value = Value * 16 + (**p) - '0';

      if (i & 1) // Odd
      {
        BdAddr->Byte[j++] = Value;

        Value = 0;
      }
    }
    i++;

    (*p)++;
  }

  if (i == 12)
    return true; // Good syntax
  else
    return false;
}


//------------------------------------------------------------------------------
uint32 UT_GetHex(char **p, int DefaultValue)
{
  uint32 Value = 0;
  bool   UseDefault;

  UseDefault = true;
  UT_SkipBlanks(p);

  while ( ((**p)<= '9' && (**p)>= '0') ||
    ((**p)<= 'f' && (**p)>= 'a') ||
    ((**p)<= 'F' && (**p)>= 'A') )
  {
    if (**p >= 'a')
      Value = Value * 16 + (**p) - 'a' + 10;
    else if (**p >= 'A')
      Value = Value * 16 + (**p) - 'A' + 10;
    else
      Value = Value * 16 + (**p) - '0';
    UseDefault = false;
    (*p)++;
  }

  if (UseDefault)
    return DefaultValue;
  else
    return Value;
}

//------------------------------------------------------------------------------

void UT_GetStr(char **p, char *Buffer)
{
  UT_SkipBlanks(p);

  while (**p != 0 && **p != ' ')
  {
    *Buffer = **p;
    (*p)++;
    Buffer++;
  }

  *Buffer = 0;
}
//------------------------------------------------------------------------------
bool First_ww=true;
unsigned char Bdaddrww[6];
//地址与安全码处理
void Mi_ww()
{
	unsigned long int ind[16];
	sint32 i,y;
	unsigned char count;
	unsigned long int ooo;
	unsigned long int A=0x01234567;//$$$$$$$$$$$$$$$用户密钥
	unsigned long int B=0x89abcedf;//$$$$$$$$$$$$$$$用户密钥
	unsigned long int C=0xfedcba98;//$$$$$$$$$$$$$$$用户密钥
	unsigned long int D=0x76543210;//$$$$$$$$$$$$$$$用户密钥
	unsigned long int aa;
	unsigned long int bb;
	unsigned long int cc;
	unsigned long int dd;
	unsigned long int f,key_16[64],g,h;
	double ttt;
	double kkk;	
	//中间处理密钥生成//
	for(i=1;i<65;i++)
	{
		kkk=sin(i);
		if(kkk<0)
			kkk=kkk*(-1);
		ttt=4294967296*kkk;
		key_16[i-1]=ttt;
	}
	for(i=0;i<16;i++)
		ind[i]=0x00;
	ind[14]=((Bdaddrww[0]<<8)|Bdaddrww[1]);
	ind[15]=((Bdaddrww[2]<<24)|(Bdaddrww[3]<<16)|(Bdaddrww[4]<<8)|Bdaddrww[5]);
//	ind[15]=ind[15]&0xffffffff;//1个单地址单安全码
//	ind[15]=ind[15]&0xfffffff0;//16个连续地址（最低有效位）单安全码
//	ind[15]=ind[15]&0xffffff00;//256个连续地址（最低有效位）单安全码
	ind[15]=ind[15]&0xfffffc00;//1024个连续地址（最低有效位）单安全码
//	ind[15]=ind[15]&0xfffff800;//2048个连续地址（最低有效位）单安全码
//	ind[15]=ind[15]&0xfffff000;//4096个连续地址（最低有效位）单安全码
//	ind[15]=ind[15]&0xffffe000;//8192个连续地址（最低有效位）单安全码

	ind[0]=(ind[14]<<16);
	ind[0]=ind[0]+(ind[15]>>16);
	ind[1]=ind[15]<<16;

//	ind[1]=ind[1]|0x00008000;//1个单地址单安全码
//	ind[1]=ind[1]|0x00080000;//16个连续地址（最低有效位）单安全码
//	ind[1]=ind[1]|0x00800000;//256个连续地址（最低有效位）单安全码
	ind[1]=ind[1]|0x02000000;//1024个连续地址（最低有效位）单安全码
//	ind[1]=ind[1]|0x04000000;//2048个连续地址（最低有效位）单安全码
//	ind[1]=ind[1]|0x08000000;//4096个连续地址（最低有效位）单安全码
//	ind[1]=ind[1]|0x10000000;//8192个连续地址（最低有效位）单安全码
	//Add length
	ind[14]=0; 
//	ind[15]=48;//1个单地址单安全码
//	ind[15]=44;//16个连续地址（最低有效位）单安全码
//	ind[15]=40;//256个连续地址（最低有效位）单安全码
	ind[15]=38;//1024个连续地址（最低有效位）单安全码
//	ind[15]=37;//2048个连续地址（最低有效位）单安全码
//	ind[15]=36;//4096个连续地址（最低有效位）单安全码
//	ind[15]=35;//8192个连续地址（最低有效位）单安全码
	////该段程序与VC++算法处理程序必须一致################################################开始		
	aa=A;
	bb=B;
	cc=C;
	dd=D;
	count=0;
	//循环计算处理
	//NO.1-1
	f=((bb&cc)|((~bb)&dd));
	ooo=aa+f+ind[0]+key_16[count];
	for(i=0;i<7;i++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
    aa=bb+ooo;
	count++;
	
    f=((aa&bb)|((~aa)&cc));
	ooo=dd+f+ind[1]+key_16[count];
	for(i=0;i<12;i++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	dd=aa+ooo;
	count++;

    f=((dd&aa)|((~dd)&bb));
	ooo=cc+f+ind[2]+key_16[count];
	for(i=0;i<17;i++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	cc=dd+ooo;
	count++;
    
    f=((cc&dd)|((~cc)&aa));
	ooo=bb+f+ind[3]+key_16[count];
	for(i=0;i<22;i++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	bb=cc+ooo;
	count++;
	//1-2
    f=((bb&cc)|((~bb)&dd));
	ooo=aa+f+ind[4]+key_16[count];
	for(y=0;y<7;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	aa=bb+ooo;
	count++;

    f=((aa&bb)|((~aa)&cc));
	ooo=dd+f+ind[5]+key_16[count];
	for(y=0;y<12;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	dd=aa+ooo;
	count++;

    f=((dd&aa)|((~dd)&bb));
	ooo=cc+f+ind[6]+key_16[count];
	for(y=0;y<17;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	cc=dd+ooo;
	count++;

    f=((cc&dd)|((~cc)&aa));
	ooo=bb+f+ind[7]+key_16[count];
	for(y=0;y<22;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	bb=cc+ooo;
	count++;
 	//1-3
	f=((bb&cc)|((~bb)&dd));
	ooo=aa+f+ind[8]+key_16[count];
	for(y=0;y<7;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
    aa=bb+ooo;
	count++;
    
    f=((aa&bb)|((~aa)&cc));
	ooo=dd+f+ind[9]+key_16[count];
	for(y=0;y<12;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	dd=aa+ooo;
	count++;
			    
    f=((dd&aa)|((~dd)&bb));
	ooo=cc+f+ind[10]+key_16[count];
	for(y=0;y<17;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	cc=dd+ooo;
	count++;

    f=((cc&dd)|((~cc)&aa));
	ooo=bb+f+ind[11]+key_16[count];
	for(y=0;y<22;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	bb=cc+ooo;
	count++;
	//1-4
	f=((bb&cc)|((~bb)&dd));
	ooo=aa+f+ind[12]+key_16[count];
	for(y=0;y<7;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
    aa=bb+ooo;
	count++;

    f=((aa&bb)|((~aa)&cc));
	ooo=dd+f+ind[13]+key_16[count];
	for(y=0;y<12;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	dd=aa+ooo;
	count++;


    f=((dd&aa)|((~dd)&bb));
	ooo=cc+f+ind[14]+key_16[count];
	for(y=0;y<17;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	cc=dd+ooo;
	count++;

    f=((cc&dd)|((~cc)&aa));
	ooo=bb+f+ind[15]+key_16[count];
	for(y=0;y<22;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
	bb=cc+ooo;
	count++;
    //NO.2-1
	g=(bb&dd)|(cc&(~dd));
	ooo=aa+g+ind[1]+key_16[count];
	for(y=0;y<5;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}
    aa=bb+ooo;
	count++;

    g=((aa&bb)|((~aa)&cc));
	ooo=dd+g+ind[6]+key_16[count];
	for(y=0;y<9;y++)
	{
		if((ooo&0x80000000)==0x80000000)
		{
			ooo=ooo<<1;
			ooo++;
		}
		else
			ooo=ooo<<1;
	}