connectinfo.cpp

一个与金融方面有关的问题

	//发送封包
	postSend(AllocSendBuff((CHAR*)&retFlag,sizeof(RETFLAG)));
	this->postRecv(pOl);
}
/*
	1）handleFindBalance（）查询余额
	2）参数pPack解密后的数据首地址
	3）参数LPOVERLAPPEDEX pOverlappedEx
		扩展OVERLAPPEDEX结构
		以更好的记录数据
		typedef struct OverlappedEX
		{
			OVERLAPPED				Overlapped;
			WSABUF					DataBuf;
			int						nOvFlag;//重叠类型
		}OVERLAPPEDEX,*LPOVERLAPPEDEX;
	4）参数len是接解密数据的长度
*/
void CConnectInfo::handleFindBalance(BYTE *pPack,LPOVERLAPPEDEX pOl,int len)
{
	//转换存储空间到LPFIND_BALANCE_REQ类型
	LPFIND_BALANCE_REQ lPack=(LPFIND_BALANCE_REQ)pPack;
	//准备打包数据
	FIND_PACKET findPacket;
	memset(&findPacket,0,sizeof(FIND_PACKET));
	//根据访问数据库的返回值 发送封包到客户端
	CDB db;
	if(db.findBalance(lPack->accountId,lPack->accountPwd,&findPacket.cBalance[0]))
	{
		//打包余额封包
		findPacket.wCode=SERVER_FIND;
		findPacket.wLen=sizeof(FIND_PACKET);
		strcpy(&findPacket.accountId[0],lPack->accountId);
		postSend(AllocSendBuff((char*)&findPacket,sizeof(FIND_PACKET)));
	}else
	{
		//打包返回标志
		RETFLAG retFlag;
		memset(&retFlag,0,sizeof(RETFLAG));
		retFlag.wCode=SERVER_FIND_ERR;
		retFlag.wLen=sizeof(RETFLAG); 
		postSend(AllocSendBuff((char*)&retFlag,sizeof(RETFLAG)));
	}
		
	postRecv(pOl);
}
/*
	1）handleIncomePacket（）处理存款封包
	2）参数pPack解密后的数据首地址
	3）参数LPOVERLAPPEDEX pOverlappedEx
		扩展OVERLAPPEDEX结构
		以更好的记录数据
		typedef struct OverlappedEX
		{
			OVERLAPPED				Overlapped;
			WSABUF					DataBuf;
			int						nOvFlag;//重叠类型
		}OVERLAPPEDEX,*LPOVERLAPPEDEX;
	4）参数len是接解密数据的长度
*/
void CConnectInfo::handleIncomePacket(BYTE *pPack,LPOVERLAPPEDEX pOl,int len)
{//处理存款封包
	LPINMONEY_PACKET lPack=(LPINMONEY_PACKET)pPack;
	strcpy(lPack->opBankIP,inet_ntoa(netaddr.sin_addr));
	//打包返回封包
	RETFLAG retFlag;
	memset(&retFlag,0,sizeof(RETFLAG));
	retFlag.wCode=SERVER_INMONEY;
	retFlag.wLen=sizeof(RETFLAG); 
	//根据数据库的返回值设置返回封包的标志
	CDB db;
	int ret=db.InMoney(lPack->accountId,lPack->accountPwd,lPack->moneyNum,lPack->opBankIP);
	switch(ret)
	{
	case 1:
		{//成功
			retFlag.bFlag=FLAG_SUCCEED;
		}break;
	case -1:
		{//账号密码错误
			retFlag.bFlag=FLAG_ACCPWD_ERR;
		}break;
	case -2:
		{//没有银行
			retFlag.bFlag=FLAG_NOBANK;
		}break;
	case 0:
	default:
		{////失败
			retFlag.bFlag=FLAG_FAILED;
		};
	
	}
	//发送打包好的数据
	postSend(AllocSendBuff((CHAR*)&retFlag,sizeof(RETFLAG)));
	this->postRecv(pOl);
}
/*
	1）handlePayoutPackett（）处理取款封包
	2）参数pPack解密后的数据首地址
	3）参数LPOVERLAPPEDEX pOverlappedEx
		扩展OVERLAPPEDEX结构
		以更好的记录数据
		typedef struct OverlappedEX
		{
			OVERLAPPED				Overlapped;
			WSABUF					DataBuf;
			int						nOvFlag;//重叠类型
		}OVERLAPPEDEX,*LPOVERLAPPEDEX;
	4）参数len是接解密数据的长度
*/
void CConnectInfo::handlePayoutPacket(BYTE* pPack,LPOVERLAPPEDEX pOl,int len)
{//处理取款封包
	LPOUTMONEY_PACKET lPack=(LPOUTMONEY_PACKET)pPack;
	strcpy(lPack->opBankIP,inet_ntoa(netaddr.sin_addr));
	//打包返回封包
	RETFLAG retFlag;
	memset(&retFlag,0,sizeof(RETFLAG));
	retFlag.wCode=SERVER_INMONEY;
	retFlag.wLen=sizeof(RETFLAG); 
	//访问数据库 并判断操作结果
	CDB db;
	int ret=db.OutMoney(lPack->accountId,lPack->accountPwd,lPack->moneyNum,lPack->opBankIP);
	switch(ret)
	{
	case 1:
		{//操作成功
			retFlag.bFlag=FLAG_SUCCEED;
		}break;
	case -1:
		{//账号或密码错误
			retFlag.bFlag=FLAG_ACCPWD_ERR;
		}break;
	case -2:
		{//没有要操作的银行
			retFlag.bFlag=FLAG_NOBANK;
		}break;
	case -3:
		{//余额不足
			retFlag.bFlag=FLAG_MONEY_ERR;
		}break;
	case 0:
	default:
		{//操作失败
			retFlag.bFlag=FLAG_FAILED;
		};
	
	}
	postSend(AllocSendBuff((CHAR*)&retFlag,sizeof(RETFLAG)));
	this->postRecv(pOl);

}
/*
	1）handleTransferPacket处理转帐封包
	2）参数pPack解密后的数据首地址
	3）参数LPOVERLAPPEDEX pOverlappedEx
		扩展OVERLAPPEDEX结构
		以更好的记录数据
		typedef struct OverlappedEX
		{
			OVERLAPPED				Overlapped;
			WSABUF					DataBuf;
			int						nOvFlag;//重叠类型
		}OVERLAPPEDEX,*LPOVERLAPPEDEX;
	4）参数len是接解密数据的长度
*/
void CConnectInfo::handleTransferPacket(BYTE* pPack,LPOVERLAPPEDEX pOl,int len)
{//处理转帐封包
	LPTRANSFER_MONEY_PACKET lPack=(LPTRANSFER_MONEY_PACKET)pPack;
	strcpy(lPack->opBankIP,inet_ntoa(netaddr.sin_addr));
	//打包返回标志
	RETFLAG retFlag;
	memset(&retFlag,0,sizeof(RETFLAG));
	retFlag.wCode=SERVER_INMONEY;
	retFlag.wLen=sizeof(RETFLAG); 
	//调用数据库存储过程进行转帐
	CDB db;
	int ret=db.TransferMoney(lPack->accountId,lPack->accountPwd,lPack->moneyNum,lPack->opBankIP,lPack->inAccountId);
	switch(ret)
	{
	case 1:
		{//成功
			retFlag.bFlag=FLAG_SUCCEED;
		}break;
	case -1:
		{//转帐账号或密码错误
			retFlag.bFlag=FLAG_ACCPWD_ERR;
		}break;
	case -2:
		{retFlag.bFlag=FLAG_YESACC;
			//retFlag.bFlag=FLAG_NOBANK;
		}break;
	case -3:
		{//登陆银行错误
			retFlag.bFlag=FLAG_NOBANK;
		}break;
	case -4:
		{//转出账号余额不足
			retFlag.bFlag=FLAG_MONEY_ERR;
		}break;
	case 0:
	default:
		{//操作失败
			retFlag.bFlag=FLAG_FAILED;
		};
	
	}
	//发送操作结果
	postSend(AllocSendBuff((CHAR*)&retFlag,sizeof(RETFLAG)));
	this->postRecv(pOl);

}
////////////////////////////////////////////////////

//利用key产生动态vkey
void CConnectInfo::ProduceNewKey(const BYTE *key, BYTE *vkey)
{
	int a, b;
	//b = (int)&a;                      //读取局部变量地址
	__asm lea eax, a;
	__asm mov ebx, [ebp + 4];
	//__asm mov ebx, [ebx + 4];         //读取二级返回地址
	__asm mov ecx, vkey;
	__asm mov word ptr [ecx], ax;
	__asm mov word ptr [ecx + 4],bx;
	__asm lea eax, b;
	__asm mov ebx, [ebp];
	__asm mov ebx, [ebx + 4];           //读取二级返回地址
	__asm mov word ptr [ecx + 6], ax;
	__asm mov word ptr [ecx + 2], bx;
	//*(int *)vkey = b;
	//*(int *)(vkey + 4) = (int)&b;
	
	for(int i = 0; i < 8; i++)       //key前4个字节和局部变量地址异或产生vkey前4个字节
		vkey[i] ^= key[i];           //,key后4个字节和二级返回地址异或产生vkey后四个字节
}

//利用key产生vkey所要插入封包的位置放在pos[8]中
void CConnectInfo::position(const BYTE *key, BYTE *pos, int len)
{
	for(int i = 0; i < 8; i++)        //得到8个插入位置(0-100,100为长度)
		pos[i] = key[i] % (len + 9);
	for(int i = 0; i < 8; i++)        //如果插入位置为0的话改成1
		if(0 == pos[i])pos[i] = 1;
}

//按pos位置把vkey插入到封包中再次打包放在outChar中
void CConnectInfo::ReWriteBag(const BYTE *pos, const BYTE *vkey, const BYTE *inChar, BYTE * outChar, int len, BYTE flag)
{
	outChar[len + 8] = flag;              //把标志位插入outChar[len+9]最后一个字节
	for(int i = 0; i < len; i++)                  //首先把数据密文拷贝到outChar[108]中,预留了8个字节存放动态vkey
		outChar[i] = inChar[i];         
	int currentLen = len;
	for(int i = 0; i < 8; i++)                   //8个字节一个一个插入，从左到右插入
	{
		if(pos[i] > currentLen) outChar[pos[i] - 1] = vkey[i];      //如果插入位置大于当前长度，就不必移动其它字节
		else                                                 //否则就要移动其它字节空出一个字节以便插入了
		{
			for(int j = currentLen; j >= pos[i]; j--)               //移动其它字节
				outChar[j] = outChar[j - 1];
			outChar[j] = vkey[i];                            //插入
		}
		currentLen++;                                              //当前长度加1
	}
}

//按照pos位置从封包中取出vkey[8],剩下的数据放在inChar中
void CConnectInfo::ReduceBag(const BYTE *pos, BYTE *outChar, BYTE *vkey, BYTE *inChar, int len)
{
	int currentLen = len + 8;
	for(int i = 7; i >= 0; i--)                //取出vkey,共8个字节,一个一个取,从右到左取出
	{
		vkey[i] = outChar[pos[i] - 1];         //首先要取出的放到vkey中去
		for(int j = pos[i]; j <= currentLen - 1; j++) //每取出一个字节就要把后面的字节一个一个移上来
			outChar[j - 1] = outChar[j];
		currentLen--;                                 //当前长度减1
	}
	for(int i = 0; i < len; i++)               //取出vkey后的封包放到inChar[100]中去,此时inChar就是取出了vkey的密文了
		inChar[i] = outChar[i];
}

//对数据包进行加密
void CConnectInfo::EnCode(const BYTE *key, BYTE *inChar, int len)
{
	for(int i = 0; i < len; i++)
		inChar[i] ^= key[i % 8];
}

//对数据包进行解密,加密算法的逆序
void CConnectInfo::DeCode(const BYTE *key, BYTE *inChar, int len)
{
	for(int i = 0; i < len; i++)
		inChar[i] ^= key[i % 8];
}

//填充客户端和服务器端交互所用到的key
void CConnectInfo::FillinKey(BYTE *key, const BYTE *vkey)
{
	for(int i = 0; i < 8; i++)
	//	key[i] = vkey[i];
	{
		__asm mov edi, vkey;
		__asm mov esi, key;
		__asm add edi, i;
		__asm add esi, i;
		__asm mov al, byte ptr [edi];
		__asm mov byte ptr [esi], al;
	}
}

//发包时：
//DataPack存放着原数据
//len为DataPack封包长度,HandlePack长度为(len+9),标志位插在最后一个字节里
void CConnectInfo::EnCodeFlow(BYTE *key, BYTE *vkey, BYTE *DataPack, BYTE *HandledPack, int len, BYTE flag)
{
	BYTE pos[8];
	EnCode(key, DataPack, len);  //加密数据包
	if(0x13 == flag)
	{
		ProduceNewKey(key, vkey);  //产生动态vkey
		position(key, pos, len);    //利用key产生插入位置放在pos[8]中
		ReWriteBag(pos, vkey, DataPack, HandledPack, len, flag);  //重新打包放在HandledPack[len+9]中
		FillinKey(key, vkey);
	}
	else
	{
		for(int i = 0; i < len; i++)
			HandledPack[i] = DataPack[i];
		HandledPack[len + 8] = flag;
	}
	//HandledPack中存放着密文
}
//接包时：
//HandledPack存放着密文
//len为DataPack封包长度,HandlePack长度为(len+9)
BYTE CConnectInfo::DeCodeFlow(BYTE *key, BYTE *vkey, BYTE *DataPack, BYTE *HandledPack, int len)	
{
	BYTE flag = HandledPack[len + 8];
	if(0x13 == flag)       //如果是最后一个包就要从里面取出动态密钥
	{
		BYTE pos[8];
		position(key, pos, len);      //利用key产生插入位置放在pos[8]中
		ReduceBag(pos, HandledPack, vkey, DataPack, len);  //把要交换的动态密钥从HandledPack抽出放到vkey去，抽出后的HandledPack存到DataPack中去
	}
	else                          //如果不是最后一个包就不要取密钥
	{
		for(int i = 0; i < len; i++)
			DataPack[i] = HandledPack[i];
	}

	DeCode(key, DataPack, len);    //对DataPack包解密
	FillinKey(key, vkey);   //用接受到的动态vkey填充key
	return flag;
	//DataPack中存放着明文
}

//key进行解密
void CConnectInfo::DeCodeKey(BYTE *key)
{
	char var_array[10] = "dengchong";
	//for(int i = 0; i < 8; i++)
	//	scanf("%c", &var_array[i]);
		//cin>>var_array[i];
	for(int i = 0; i < 8; i++)
		key[i] ^= var_array[i];
}
//key进行加密
void CConnectInfo::EnCodeKey(BYTE *key)
{
	char var_array[10] = "dengchong";
	//for(int i = 0; i < 8; i++)
	//	scanf("%c", &var_array[i]);
		//cin>>var_array[i];
	for(int i = 0; i < 8; i++)
		key[i] ^= var_array[i];
}
//加密金钱数据
void CConnectInfo::EnCodeMoney(BYTE *key, BYTE *vkey, BYTE *DataPack, BYTE *HandledPack)
{
	BYTE pos[8];
	BlowFish BF;
	BF.gBlowFishInit(key);
	BF.gBlowFishEnCode(DataPack, DataPack);
	ProduceNewKey(key, vkey);
	position(key, pos, 8);
	ReWriteBag(pos, vkey, DataPack, HandledPack, 8, 0x13);
	FillinKey(key, vkey);
}

void CConnectInfo::DeCodeMoney(BYTE *key, BYTE *vkey, BYTE *DataPack, BYTE *HandledPack)
{
	BYTE pos[8];
	position(key, pos, 8);
	ReduceBag(pos, HandledPack, vkey, DataPack, 8);
	BlowFish BF;                                    
	BF.gBlowFishInit(key);                  
	BF.gBlowFishDeCode(DataPack, DataPack);
	FillinKey(key, vkey);
}