int SendToServer(gw_server_info_t* svr,int funcno,const char* data)
{
int ret = E_POWER_INTERNAL_ERR;
int sendbytes = 0;
if(!svr->sock->ConnectTcp(svr->server_ip,svr->server_port,5))
{
return E_POWER_CONN_SVR;
}
KSG_GW_PACK_t * pack = NULL;
int datalen = strlen(data);
int packlen = sizeof(KSG_GW_PACK_t) - sizeof(char[1]) + datalen;
if((pack = (KSG_GW_PACK_t*)malloc(packlen)) == NULL)
{
ret = E_POWER_INTERNAL_ERR;
}
else
{
memset(pack,0,packlen);
pack->func_no = htonl(funcno);
pack->length = htonl(datalen);
pack->enc_type = 0;
pack->pack_index = htonl(1);
pack->next_pack = 0;
memcpy(pack->data,data,datalen);
CalcMD5((unsigned char*)pack->data,datalen,(unsigned char*)pack->CRC);
sendbytes = svr->sock->Send((char*)pack,packlen);
if(-1 == sendbytes)
{
ret = E_POWER_CONN_SVR;
}
else if(-2 == sendbytes || sendbytes != packlen)
{
ret = E_POWER_TRANS_ERR;
}
else
{
//成功
ret = 0;
}
}
if(pack)
free(pack);
// 如果处理失败,关闭连接
if(ret)
svr->sock->Close();
return ret;
}
static int packege_search_data(ST_PACK *in_pack,char *send_data){
int ret;
ext_elect_search_req_t* elect_search_req_t;
elect_search_req_t=(ext_elect_search_req_t*)send_data;
unsigned char buf[68]="";
unsigned char soutmd5[16]="";
char outmd5[32]="";
T_t_pif_card tCard;
memset(&tCard,0,sizeof(tCard));
memcpy(elect_search_req_t->prix,"1",1);
memcpy(elect_search_req_t->length,"0103",4);
memcpy(elect_search_req_t->type,"0006",4);
memset(elect_search_req_t->bitery,'0',sizeof(elect_search_req_t->bitery));
sprintf(elect_search_req_t->room,"%-20s",in_pack->saddr);
ret=DB_t_pif_card_read_by_card_id(in_pack->lvol0, &tCard);
if(ret)
{
if(DB_NOTFOUND==ret)
ret=E_CARDNO_NOT_EXIST;
else
ret=E_DB_CARD_R;
return ret;
}
sprintf(elect_search_req_t->cutid,"%-22d",tCard.cosumer_id);//客户号
memcpy(elect_search_req_t->relate,"1",1);//对应关系
memcpy(elect_search_req_t->clientid,"0001",4);
memset(outmd5,'0',32);
memcpy(buf,elect_search_req_t->type,67);
writelog(LOG_ERR,"buf data=[%s]",buf);
CalcMD5(buf,67,soutmd5);
dec2hex(soutmd5,16,outmd5);
writelog(LOG_ERR,"outmd5 data=[%s]",outmd5);
sprintf(elect_search_req_t->signcheck,"%s",outmd5);
return 0;
}
static
rc_t CC KWGAEncFileRead (const KWGAEncFile *cself,
uint64_t pos,
void *buffer,
size_t bsize,
size_t *num_read)
{
KWGAEncFile * self = (KWGAEncFile *)cself; /* mutable values */
rc_t rc = 0;
assert (cself);
assert (buffer);
assert (num_read);
*num_read = 0;
/* are we even within the file? If not just say no. Drugs are bad Mmmkay */
if (pos >= self->file_size)
{}
/* are we not reading from out what is already in the decrypted buffer space? */
else
{
if ((self->buffer.valid == 0) ||
(pos < self->buffer.offset) ||
(pos >= (self->buffer.offset + self->buffer.valid)))
{
if (pos < self->block_size) /* we'll be reading from the first 'block' */
{
rc = KWGAEncFileReadInt (self, 0, self->block_size);
if (rc)
{
LOGERR (klogErr, rc, "error reading first data block of"
" encrypted file");
return rc;
}
if (self->buffer.valid > self->block_size)
{
rc = RC (rcFS, rcFile, rcReading, rcBuffer, rcTooBig);
LOGERR (klogInt, rc, "read wrong amount for first block");
return rc;
}
else
{
size_t md5_size;
size_t nudge = 0;
char md51_comp [32];
if (self->buffer.valid & (ECB_BYTES-1))
nudge = ECB_BYTES - (self->buffer.valid & (ECB_BYTES-1));
if (nudge)
memset (self->buffer.data + self->buffer.valid, 0, nudge);
md5_size = self->buffer.valid + nudge;
CalcMD5 (self->buffer.data, md5_size, md51_comp);
#if 1
if (strcase_cmp (self->md51, string_size(self->md51),
md51_comp, string_size(md51_comp), 32) != 0)
#else
if (strncasecmp (self->md51, md51_comp, 32) != 0)
#endif
{
rc = RC (rcFS, rcFile, rcReading, rcConstraint, rcCorrupt);
LOGERR (klogErr, rc, "MD5 does not match in decryption");
return rc;
}
}
}
else /* if (pos >= self->block_size) */
{
rc = KWGAEncFileReadInt (self, (pos & ~ ( uint64_t ) (16-1)),
DEFAULT_BUFF_SIZE);
if (rc)
{
LOGERR (klogErr, rc, "error reading data block of"
" encrypted file");
return rc;
}
} /* if (pos < self->block_size) */
} /* if ((self->buffer.valid == 0) || etc. */
/* if here we have a valid buffer and it contains the start pos requested */
/* assert (pos >= self->buffer.offset); */
/* assert (pos < (self->buffer.offset +self->buffer.valid)); */
{
size_t start;
size_t limit;
/* find offset of start for copy within the buffer */
start = (size_t)(pos - self->buffer.offset);
/* how many bytes available starting here */
limit = self->buffer.valid - start;
if (pos + limit > self->file_size)
limit = self->file_size - pos;
/* are we asking to read more than we have? is so trim the request */
if (limit < bsize)
bsize = limit;
memmove (buffer, self->buffer.data + start, bsize);
*num_read = bsize;
}
}
return 0;
}
static int packege_elec_request(ST_PACK *in_pack,int flag,char *send_data){
int ret;
ext_elect_req_t* elect_req_t;
elect_req_t=(ext_elect_req_t*)send_data;
double money=0; //充值金额
char serialno[10]="";
char sysdate[11]="";
char systime[9]="";
char sysdatetime[20]="";
unsigned char buf[106]="";
unsigned char soutmd5[16]="";
char outmd5[32]="";
T_t_pif_card tCard;
memset(&tCard,0,sizeof(tCard));
if(flag==1){//房间查询不加密
memcpy(elect_req_t->prix,"0",1);
}else{
memcpy(elect_req_t->prix,"1",1);
}
memcpy(elect_req_t->length,"0141",4);
if(flag==1){
memcpy(elect_req_t->type,"0001",4);
}else if(flag==2){
memcpy(elect_req_t->type,"0002",4);
}
memset(elect_req_t->bitery,'0',sizeof(elect_req_t->bitery));
sprintf(elect_req_t->room,"%-20s",in_pack->saddr);
ret=DB_t_pif_card_read_by_card_id(in_pack->lvol0, &tCard);
if(ret)
{
if(DB_NOTFOUND==ret)
ret=E_CARDNO_NOT_EXIST;
else
ret=E_DB_CARD_R;
return ret;
}
sprintf(elect_req_t->cutid,"%-22d",tCard.cosumer_id);
money = in_pack->damt1;
int i_money=D2I(D4U5(money*100,0));
sprintf(elect_req_t->money,"%07d",i_money);
ret=get_datetime_from_db(sysdate,systime);
if(ret)
{
writelog(LOG_ERR,"get_datetime_from_db error,error code=[%d]",ret);
getsysdate(sysdate);
getsystime(systime);
}
strcpy(sysdatetime,sysdate+4);
strcat(sysdatetime,systime);
memcpy(elect_req_t->datetime,sysdatetime,10);
memcpy(elect_req_t->tracenum,sysdate,8);
sprintf(serialno,"%010d",in_pack->lvol6);
memcpy(elect_req_t->tracenum+8,serialno,10);
memcpy(elect_req_t->retnum,"0000",4);
memcpy(elect_req_t->clientid,"0001",4);
memset(outmd5,'0',32);
if(flag==1){
sprintf(elect_req_t->signcheck,"%s",outmd5);
}else if(flag==2){
memcpy(buf,elect_req_t->type,105);
writelog(LOG_ERR,"buf data=[%s]",buf);
CalcMD5(buf,105,soutmd5);
dec2hex(soutmd5,16,outmd5);
writelog(LOG_ERR,"outmd5 data=[%s]",outmd5);
sprintf(elect_req_t->signcheck,"%s",outmd5);
}
return 0;
}
int __stdcall decrypt_elec_card_pwd(int cut_id,const char seedkey[32],const char mpwd[64],char pwd[8])
{
char temp[17],temp1[17],buf[17];
char encrypt_seed[65];
unsigned char radom_seed[4];
keyInstance key_inst;
cipherInstance cipher_inst;
int i,len;
static const int max_pwd_len = 8;
memset(&key_inst,0,sizeof key_inst);
memset(&cipher_inst,0,sizeof cipher_inst);
// 读取随机种子
memcpy(temp,mpwd,8);
memset(temp1,0,sizeof temp1);
for(i = 0;i < 8;i+=2)
{
memcpy(temp1,temp+i,2);
radom_seed[i/2] = (unsigned char)strtoul(temp1,NULL,16);
}
// 计算种子密钥
memset(encrypt_seed,0,sizeof encrypt_seed);
for(i = 0;i < 32;++i)
encrypt_seed[i] = seedkey[i] ^ radom_seed[i%4];
CalcMD5((unsigned char*)encrypt_seed,32,(unsigned char*)temp);
memset(encrypt_seed,0,sizeof encrypt_seed);
for(i = 0; i < 16 ;++i)
sprintf(encrypt_seed+i*2,"%02X",(unsigned char)temp[i]);
// 解密
if(makeKey(&key_inst,DIR_DECRYPT,128,(char*)encrypt_seed)==FALSE)
{
return -1;
}
if(cipherInit(&cipher_inst,MODE_CBC,NULL)==FALSE)
{
return -1;
}
memset(temp1,0,sizeof temp1);
memset(temp,0,sizeof temp);
for(i = 0;i < 32; i+=2)
{
memcpy(temp1,mpwd+12+i,2);
temp[i/2] = (unsigned char)strtoul(temp1,NULL,16);
}
memset(temp1,0,sizeof temp1);
len = blockDecrypt(&cipher_inst,&key_inst,(BYTE*)temp,16*8,(BYTE*)temp1);
for(i=0;i < max_pwd_len;++i)
buf[i] = temp1[i] ^ radom_seed[i%4];
// 计算密码
sprintf(temp,"%08X",cut_id);
for(i = 0;i < max_pwd_len;++i)
temp1[i] = temp1[i] ^ temp[i];
// CRC 校验
uint16 crc = GenerateCRC16((unsigned char*)temp1,max_pwd_len);
memset(temp,0,sizeof temp);
sprintf(temp,"%04X",crc);
if(strncmp(temp,mpwd+8,4))
{
return -2;
}
memcpy(pwd,buf,max_pwd_len);
//memcpy(pwd,temp1,max_pwd_len);
return 0;
}
int __stdcall encrypt_elec_card_pwd(int cut_id,const char seedkey[32],const char pwd[8],char mpwd[64])
{
static const int max_pwd_len = 8;
keyInstance key_inst;
cipherInstance cipher_inst;
unsigned char buf[16] = "";
char temp[16] = "";
char temp2[16] = "";
char pwd_str[max_pwd_len*2+1] = "";
unsigned char decrypt_buf[16] = "";
char encrypt_seedkey[64] = "";
unsigned char decrypt_str[64] = "";
time_t radom_seed = time(NULL);
int len,i,j,pwd_len;
memset(&key_inst,0,sizeof key_inst);
memset(&cipher_inst,0,sizeof cipher_inst);
for(i = 0;i < max_pwd_len;++i)
{
switch(pwd[i])
{
case ' ':
case '\t':
case '\r':
case '\n':
case '\'':
case '"':
case '%':
case '_':
return -2;
default:
break;
}
}
pwd_len = strlen(pwd);
if(pwd_len > max_pwd_len)
return -3;
// 取4位随机种子
srand((unsigned int)radom_seed);
for(i = 0;i < 4;++i)
buf[i] = (unsigned char)(rand() % 0xFF);
// 密码不足8位右补空格
memcpy(pwd_str,pwd,pwd_len);
for(i=pwd_len;i < max_pwd_len;++i)
pwd_str[pwd_len] = ' ';
for(i=0;i < max_pwd_len;++i)
pwd_str[i] ^= buf[i%4];
// 加密的密钥
for(i = 0;i < max_pwd_len;++i)
pwd_str[max_pwd_len+i] = pwd_str[i] | (!temp[i]);
memcpy(pwd_str+max_pwd_len,pwd_str,max_pwd_len);
// 计算种子密钥
memset(encrypt_seedkey,0,sizeof encrypt_seedkey);
for(i = 0; i < 32 ;++i)
encrypt_seedkey[i] = seedkey[i] ^ buf[i%4];
CalcMD5((unsigned char*)encrypt_seedkey,32,(unsigned char*)temp);
memset(encrypt_seedkey,0,sizeof encrypt_seedkey);
for(i = 0,j = 0;i < 16; ++i)
j += sprintf(encrypt_seedkey+j,"%02X",(unsigned char)temp[i]);
// 计算CRC
sprintf(temp,"%08X",cut_id);
memset(temp2,0,sizeof temp2);
for(i = 0;i < max_pwd_len;++i)
temp2[i] = pwd_str[i] ^ temp[i];
uint16 crc = GenerateCRC16((unsigned char *)temp2,max_pwd_len);
sprintf(temp,"%04X",crc);
memcpy(buf+4,temp,4);
// 进行加密
if(makeKey(&key_inst,DIR_ENCRYPT,128,encrypt_seedkey)==FALSE)
{
return -1;
}
if(cipherInit(&cipher_inst,MODE_CBC,NULL)==FALSE)
{
return -1;
}
len = blockEncrypt(&cipher_inst,&key_inst,(unsigned char*)pwd_str,16*8,decrypt_str);
if(len == 16*8)
{
// 8 个字符种子
for(i = 0;i < 4; ++i)
sprintf(mpwd+i*2,"%02X",(unsigned char)buf[i]);
// 4 个字符CRC
memcpy(mpwd+8,temp,4);
// 8 个字符密码
for(i = 0;i < 16;++i)
sprintf(mpwd+12+i*2,"%02X",decrypt_str[i]);
//mpwd[28] = '\0';
return 0;
}
return -1;
}
int makepaysenddata(payelect &Tdata,kst_ald_pay &pay)
{
char log[1024]="[gateway_receive]支付请求：";
char strlog[1024]="";
char str[1024]="";
char mdstr[1024]="";
int offset;
unsigned char inmd5[105]="";
unsigned char soutmd5[32]="";
char signature[33]="";
kst_ald_pay *ald_pay=&pay;
payelect *query=&Tdata;
memset(query,0,sizeof(query));
strncpy(query->discern,"1",1);
strncpy(str,query->discern,sizeof(query->discern));
strcat(strlog,str);
strncpy(query->length,"0142",4);
strncpy(str,query->length,sizeof(query->length));
strcat(strlog,str);
strncpy(query->type,"0002",4);
strncpy(str,query->type,sizeof(query->type));
strcat(strlog,str);
strncpy(query->bitmap,"0000000000000000",16);
strncpy(str,query->bitmap,sizeof(query->bitmap));
strcat(strlog,str);
strncpy(query->roomname,ald_pay->payaccount,sizeof(query->roomname));
strncpy(str,query->roomname,sizeof(query->roomname));
strcat(strlog,str);
strncpy(query->account,ald_pay->account,sizeof(query->account));
strncpy(str,query->account,sizeof(query->account));
strcat(strlog,str);
strncpy(query->money,ald_pay->payamt,sizeof(query->money));
strncpy(str,query->money,sizeof(query->money));
strcat(strlog,str);
strncpy(query->datetime,ald_pay->datetime,sizeof(query->datetime));
strncpy(str,query->datetime,sizeof(query->datetime));
strcat(strlog,str);
strncpy(query->tracenum,ald_pay->rfn,sizeof(ald_pay->rfn));
strncpy(str,query->tracenum,sizeof(query->tracenum));
strcat(strlog,str);
strncpy(query->retnum," ",4);
strncpy(str,query->retnum,sizeof(query->retnum));
strcat(strlog,str);
strncpy(query->station,ald_pay->trcd,sizeof(query->station));
strncpy(str,query->station,sizeof(query->station));
strcat(strlog,str);
offset=0;
memcpy(mdstr,query->type,4);
offset+=4;
memcpy(mdstr+offset,query->bitmap,16);
offset+=16;
memcpy(mdstr+offset,query->roomname,20);
offset+=20;
memcpy(mdstr+offset,query->account,22);
offset+=22;
memcpy(mdstr+offset,query->money,7);
offset+=7;
memcpy(mdstr+offset,query->datetime,10);
offset+=10;
memcpy(mdstr+offset,query->tracenum,18);
offset+=18;
memcpy(mdstr+offset,query->retnum,4);
offset+=4;
memcpy(mdstr+offset,query->station,4);
offset+=4;
memcpy(inmd5,mdstr,105);
memset(query->signature,0,sizeof(query->signature));
CalcMD5(inmd5,sizeof(inmd5),soutmd5);
dec2hex(soutmd5,16,signature);
memcpy(query->signature,signature,32);
strncpy(str,query->signature,sizeof(query->signature));
strcat(strlog,str);
strcat(log,strlog);
WriteLog(log);
return 0;
}
int RecvFromServer(gw_server_info_t* svr,KSG_GW_PACK_t** resp)
{
int ret;
int recvbytes;
int packlen;
unsigned char md5[16];
if(svr->sock->IsFree())
return E_POWER_CONN_SVR;
KSG_GW_PACK_t * pack = NULL;
if((pack = (KSG_GW_PACK_t*)malloc(sizeof(KSG_GW_PACK_t))) == NULL)
{
ret = E_POWER_INTERNAL_ERR;
}
else if((recvbytes = svr->sock->Recv((char*)pack,sizeof(int),1000)) == sizeof(int))
{
pack->length = ntohl(pack->length);
packlen = sizeof(KSG_GW_PACK_t) - sizeof(char[1]) + pack->length;
if((pack = (KSG_GW_PACK_t*)realloc(pack,packlen)) == NULL)
{
ret = E_POWER_INTERNAL_ERR;
}
else if((svr->sock->Recv(((char*)pack)+sizeof(int),packlen-sizeof(int),1000)
== (packlen-sizeof(int))))
{
if(pack->length > 0)
{
CalcMD5((unsigned char*)pack->data,pack->length,md5);
if(memcmp(md5,pack->CRC,sizeof md5))
{
writelog(LOG_ERR,"数据检查错误");
ret = E_POWER_RECV_ERR;
}
else
{
pack->func_no = ntohl(pack->func_no);
pack->pack_index = ntohl(pack->pack_index);
pack->next_pack = ntohl(pack->next_pack);
pack->retcode = ntohl(pack->retcode);
ret = 0;
}
}
else
{
pack->func_no = ntohl(pack->func_no);
pack->pack_index = ntohl(pack->pack_index);
pack->next_pack = ntohl(pack->next_pack);
pack->retcode = ntohl(pack->retcode);
ret = 0;
}
}
else
{
ret = E_POWER_CONN_SVR;
}
}
else
{
ret = E_POWER_TRANS_ERR;
}
*resp = pack;
svr->sock->Close();
return ret;
}
