vcrypt.cpp

otl简单包装实现类,对数据库进行操作的,简单易用.

/***************************************************************************
                          vcrypt.cpp  -  description
                             -------------------
    begin                : ?  9? 6 2005
    copyright            : (C) 2005 by root
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "vcrypt.h"
#include <linux/hdreg.h>
#include "vfile.h"

//--------------------------------------------------------------------------------------------------
unsigned char* VCrypt::Md5(const unsigned char* Key,unsigned long KeyLen,unsigned char* KeyResult)
{
    return ::MD5(Key,KeyLen,KeyResult);
}

bool VCrypt::Password(const char* Key,int KeyLen,char* KeyResult)
{
 	if(Key==NULL || KeyLen<=0 || KeyResult==NULL) return false;
    unsigned char Result[32];
    char strResult[33];
    memset(Result,0,32);
    ::MD5((unsigned char*)Key,KeyLen,Result);
    memset(strResult,0,33);
    for(int i=0;i<16;i++) sprintf(strResult,"%s%02x",strResult,Result[i]);
    strResult[14]=0; strResult[28]=0;
    sprintf(KeyResult,"%s%s", &strResult[5],&strResult[21]);
    return true;
}

string VCrypt::Password(string Key)
{
    char KeyResult[20];
    if(Password(Key.c_str(),Key.length(),KeyResult)) return KeyResult;
    else return "";
}

string VCrypt::ExchangeCode(string Key)
{
	char Src[]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	char Dest[]="S8FO3KCUQW1N7LJ5ZEMX2VG0BIR6Y9PND4TA";
	char KeyStr[Key.size()+1];
	memset(KeyStr,0,Key.size()+1);
	for(int i=0;i<Key.size();i++){
     	char* p = strchr(Src,Key[i]);
      	if(p) KeyStr[i]=Dest[p-Src];
       	else  KeyStr[i]=Key[i];
	}
	return KeyStr;
}

string VCrypt::Md5String(string Key)
{
    unsigned char Result[16];
    char strResult[33];
    memset(Result,0,16);
    ::MD5((unsigned char*)Key.c_str(),Key.size(),Result);
    memset(strResult,0,33);
    for(int i=0;i<16;i++) sprintf(strResult,"%s%02x",strResult,Result[i]);
	return strResult;
}

string VCrypt::Md5File(string File)
{
	unsigned char Buf[1024000],Result[16];
	char strResult[33];
	memset(Result,0,16);
	int Length = VFile::Length(File.c_str());
	if(Length>0){
		VFile f;
		if(f.Open(File.c_str(),"r")){
			MD5_CTX context;
			MD5_Init(&context);
			while((Length=f.Read(Buf,1024000))>0){
				MD5_Update(&context,Buf,Length);
			}
			MD5_Final(Result,&context);
			f.Close();
		}	
	}
    memset(strResult,0,33);
    for(int i=0;i<16;i++) sprintf(strResult,"%s%02x",strResult,Result[i]);
	return strResult;
}

string VCrypt::Md5QuickFile(string File)
{	
	unsigned char Buf[4096],Result[16];
	char strResult[33];
	memset(Result,0,16);

	int Length = VFile::Length(File.c_str());
	if(Length>0){
		int Interval = (Length>1024000)?Length/25:0;
		if(Interval==0) return Md5File(File);
		else{
			VFile f;
			if(f.Open(File.c_str(),"r")){
				MD5_CTX context;
				MD5_Init(&context);
				for(int i=0;i<25;i++){
					f.Seek(i*Interval,SEEK_SET);
					Length=f.Read(Buf,4096);
					MD5_Update(&context,Buf,Length);
				}
				f.Seek(4096,SEEK_END);
				Length=f.Read(Buf,4096);
				MD5_Update(&context,Buf,Length);
				MD5_Final(Result,&context);
				f.Close();
			}	
		}
	}
	
    memset(strResult,0,33);
    for(int i=0;i<16;i++) sprintf(strResult,"%s%02x",strResult,Result[i]);
	return strResult;
}

//--------------------------------------------------------------------------------------------------
string  VHostInfo::GetMacAddress(const char *Eth)
{
	char Hex[]="0123456789ABCDEF";
	struct sockaddr *sa;
	struct ifreq ifr;
	int sockfd;
	int i;
	char MacAddr[13];
	memset(MacAddr,0,13);
	sockfd = socket(AF_INET,SOCK_DGRAM,0);
	if(sockfd>0){
	    strcpy(ifr.ifr_name,Eth);
     	if(ioctl(sockfd,SIOCGIFHWADDR,&ifr)>=0){
	        sa = &ifr.ifr_hwaddr;
	        for(i=0;i<6;i++){
	           sprintf(MacAddr,"%s%c%c",MacAddr,Hex[(sa->sa_data[i]&0xF0)>>4],Hex[(sa->sa_data[i]&0x0F)]);
	         }
	    }
	}
	close(sockfd);
	return MacAddr;
}

string  VHostInfo::GetHDSerialNo(const char *DevHD)
{
	 struct hd_driveid id;
	 int fd = open(DevHD,O_RDONLY);
	 if(fd<0){
		return "";
	 }
	 if(ioctl(fd,HDIO_GET_IDENTITY,&id)){
		return "";
	 }
	 close(fd);
	 return (const char*)id.serial_no;
}

string VHostInfo::GenerateCode(const char *Dev)
{
     string Code;
     string NetId,HDId;
     if(Dev){
      	if(strstr(Dev,"eth")) NetId = GetMacAddress(Dev);
       	else if(strstr(Dev,"/dev/hd")) HDId = GetHDSerialNo(Dev);
     }
     else{
	     NetId = GetMacAddress("eth0");
    	 HDId = GetHDSerialNo("/dev/hda");
     }
     if(NetId.size()>0 && HDId.size()>0){
        NetId = VCrypt::ExchangeCode(NetId);
        HDId = VCrypt::ExchangeCode(HDId);
        if(HDId.size()<12){
        	int n = 12-HDId.size();
         	char tmp[13];
          	memset(tmp,0,13);
         	for(int i=0;i<n;i++){
            	tmp[i] = HDId[(n+i*n)%HDId.size()];
			}
			HDId += tmp;
		}
		Code = NetId;
		for(int i=0;i<6;i++) Code[2*i+1] = HDId[2*i+1];
	 }
	 else if(NetId.size()>0){
     	Code = VCrypt::ExchangeCode(NetId);
	 }
	 else if(HDId.size()>0){
        HDId = VCrypt::ExchangeCode(HDId);
        if(HDId.size()<12){
        	int n = 12-HDId.size();
         	char tmp[13];
          	memset(tmp,0,13);
         	for(int i=0;i<n;i++){
            	tmp[i] = HDId[(n+i*n)%HDId.size()];
			}
			HDId += tmp;
		}
	   	Code = HDId;
	 }
	 else{
      	 Code = VCrypt::ExchangeCode("WKHYPDMYAZMB");
     }
     return Code;
}

string  VHostInfo::GenerateSerialNo(const char* HostCode)
{
	string Code=HostCode;
	Code += "easeliu";
	Code = VCrypt::Password(Code);
	return Code;
}


//--------------------------------------------------------------------------------------------------
// 编码后的长度一般比原文多占1/3的存储空间，请保证base64code有足够的空间
char Base64::GetB64Char(int index)
{
	const char szBase64Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	if (index >= 0 && index < 64)
		return szBase64Table[index];
	
	return '=';
}

int Base64::GetB64Index(char ch)
{
	int index = -1;
	if (ch >= 'A' && ch <= 'Z')
	{
		index = ch - 'A';
	}
	else if (ch >= 'a' && ch <= 'z')
	{
		index = ch - 'a' + 26;
	}
	else if (ch >= '0' && ch <= '9')
	{
		index = ch - '0' + 52;
	}
	else if (ch == '+')
	{
		index = 62;
	}
	else if (ch == '/')
	{
		index = 63;
	}

	return index;
}
// 从双字中取单字节
#define B0(a) (a & 0xFF)
#define B1(a) (a >> 8 & 0xFF)
#define B2(a) (a >> 16 & 0xFF)
#define B3(a) (a >> 24 & 0xFF)

// 编码后的长度一般比原文多占1/3的存储空间，请保证base64code有足够的空间
int Base64::Base64Encode(char * base64code, const char * src, int src_len) 
{   
	if (src_len == 0)
		src_len = strlen(src);
	
	int len = 0;
	unsigned char* psrc = (unsigned char*)src;
	char * p64 = base64code;
	int i;
	for (i = 0; i < src_len - 3; i += 3)
	{
		unsigned long ulTmp = *(unsigned long*)psrc;
		register int b0 = GetB64Char((B0(ulTmp) >> 2) & 0x3F); 
		register int b1 = GetB64Char((B0(ulTmp) << 6 >> 2 | B1(ulTmp) >> 4) & 0x3F); 
		register int b2 = GetB64Char((B1(ulTmp) << 4 >> 2 | B2(ulTmp) >> 6) & 0x3F); 
		register int b3 = GetB64Char((B2(ulTmp) << 2 >> 2) & 0x3F); 
		*((unsigned long*)p64) = b0 | b1 << 8 | b2 << 16 | b3 << 24;
		len += 4;
		p64  += 4; 
		psrc += 3;
	}
	
	// 处理最后余下的不足3字节的饿数据
	if (i < src_len)
	{
		int rest = src_len - i;
		unsigned long ulTmp = 0;
		for (int j = 0; j < rest; ++j)
		{
			*(((unsigned char*)&ulTmp) + j) = *psrc++;
		}
		
		p64[0] = GetB64Char((B0(ulTmp) >> 2) & 0x3F); 
		p64[1] = GetB64Char((B0(ulTmp) << 6 >> 2 | B1(ulTmp) >> 4) & 0x3F); 
		p64[2] = rest > 1 ? GetB64Char((B1(ulTmp) << 4 >> 2 | B2(ulTmp) >> 6) & 0x3F) : '='; 
		p64[3] = rest > 2 ? GetB64Char((B2(ulTmp) << 2 >> 2) & 0x3F) : '='; 
		p64 += 4; 
		len += 4;
	}
	
	*p64 = '\0'; 
	
	return len;
}


// 解码后的长度一般比原文少用占1/4的存储空间，请保证buf有足够的空间
int Base64::Base64Decode(char * buf, const char * base64code, int src_len) 
{   
	if (src_len == 0)
		src_len = strlen(base64code);

	int len = 0;
	unsigned char* psrc = (unsigned char*)base64code;
	char * pbuf = buf;
	int i;
	for (i = 0; i < src_len - 4; i += 4)
	{
		unsigned long ulTmp = *(unsigned long*)psrc;
		
		register int b0 = (GetB64Index((char)B0(ulTmp)) << 2 | GetB64Index((char)B1(ulTmp)) << 2 >> 6) & 0xFF;
		register int b1 = (GetB64Index((char)B1(ulTmp)) << 4 | GetB64Index((char)B2(ulTmp)) << 2 >> 4) & 0xFF;
		register int b2 = (GetB64Index((char)B2(ulTmp)) << 6 | GetB64Index((char)B3(ulTmp)) << 2 >> 2) & 0xFF;
		
		*((unsigned long*)pbuf) = b0 | b1 << 8 | b2 << 16;
		psrc  += 4; 
		pbuf += 3;
		len += 3;
	}

	// 处理最后余下的不足4字节的饿数据
	if (i < src_len)
	{
		int rest = src_len - i;
		unsigned long ulTmp = 0;
		for (int j = 0; j < rest; ++j)
		{
			*(((unsigned char*)&ulTmp) + j) = *psrc++;
		}
		
		register int b0 = (GetB64Index((char)B0(ulTmp)) << 2 | GetB64Index((char)B1(ulTmp)) << 2 >> 6) & 0xFF;
		*pbuf++ = b0;
		len  ++;

		if ('=' != B1(ulTmp) && '=' != B2(ulTmp))
		{
			register int b1 = (GetB64Index((char)B1(ulTmp)) << 4 | GetB64Index((char)B2(ulTmp)) << 2 >> 4) & 0xFF;
			*pbuf++ = b1;
			len  ++;
		}
		
		if ('=' != B2(ulTmp) && '=' != B3(ulTmp))
		{
			register int b2 = (GetB64Index((char)B2(ulTmp)) << 6 | GetB64Index((char)B3(ulTmp)) << 2 >> 2) & 0xFF;
			*pbuf++ = b2;
			len  ++;
		}

	}
		
	*pbuf = '\0'; 
	
	return len;
} 

string Base64::Base64Encode(string src)
{
	char buf[src.size()*2];
	memset(buf,0,src.size()*2);
	Base64Encode(buf,src.c_str(),src.size());
	return buf;
}

string Base64::Base64Decode(string base64code)
{
	char buf[base64code.size()];
	memset(buf,0,base64code.size());
	Base64Decode(buf,base64code.c_str(),base64code.size());
	return buf;
}

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