int SymmDecrypt(EdpPacket* pkg){
int ret = 0;
uint32 remain_len = 0;
uint32 remain_pos = 0;
pkg->_read_pos = 1;
ReadRemainlen(pkg, &remain_len);
assert(remain_len == (pkg->_write_pos - pkg->_read_pos));
if (remain_len == 0){ /* no data for decrypting */
pkg->_read_pos = 1;
return 0;
}
remain_pos = pkg->_read_pos;
switch (g_encrypt_alg_type){
case kTypeAes:
ret = aes_decrypt(pkg, remain_pos);
break;
default:
ret = -1;
break;
}
return ret;
}
int32 UnpackSavedataAck(EdpPacket* pkg, char** json_ack)
{
uint32 remainlen;
uint8 flag;
uint16 json_len;
if (ReadRemainlen(pkg, &remainlen))
{
return ERR_UNPACK_SAVEDATA_ACK;
}
if (ReadByte(pkg, &flag))
{
return ERR_UNPACK_SAVEDATA_ACK;
}
if (ReadUint16(pkg, &json_len))
{
return ERR_UNPACK_SAVEDATA_ACK;
}
if (ReadBytes(pkg, (uint8**)(json_ack), json_len))
{
return ERR_UNPACK_SAVEDATA_ACK;
}
return 0;
}
/* ping_resp (S->C) */
int32_t UnpackPingResp(EdpPacket* pkg)
{
uint32 remainlen;
if (ReadRemainlen(pkg, &remainlen))
return ERR_UNPACK_PING_REMAIN;
my_assert(pkg->_read_pos == pkg->_write_pos);
return 0;
}
int32 UnpackEncryptResp(EdpPacket* pkg){
uint32 remainlen = 0;
uint16 key_len = 0;
unsigned rsa_size = 0;
unsigned slice_size = 0;
unsigned char key[BUFFER_SIZE] = {0};
unsigned decrypt_len = 0;
int len = 0;
unsigned char* from = 0;
unsigned char* to = 0;
uint32 i = 0;
if (ReadRemainlen(pkg, &remainlen))
return ERR_UNPACK_ENCRYPT_RESP;
if (ReadUint16(pkg, &key_len))
return ERR_UNPACK_ENCRYPT_RESP;
if (remainlen != key_len + 2)
return ERR_UNPACK_ENCRYPT_RESP;
rsa_size = RSA_size(g_rsa);
slice_size = rsa_size - RSA_PADDING_LEN;
from = pkg->_data + pkg->_read_pos;
to = key;
for (i=0; i<key_len; i+=rsa_size){
len = RSA_private_decrypt(rsa_size, from+i, to,
g_rsa, RSA_PKCS1_PADDING);
decrypt_len += len;
if (decrypt_len > BUFFER_SIZE){
return ERR_UNPACK_ENCRYPT_RESP;
}
to += len;
}
switch (g_encrypt_alg_type){
case kTypeAes:
if(AES_set_encrypt_key(key, AES_KEY_LEN, &g_aes_encrypt_key) < 0) {
return ERR_UNPACK_ENCRYPT_RESP;
}
if(AES_set_decrypt_key(key, AES_KEY_LEN, &g_aes_decrypt_key) < 0) {
return ERR_UNPACK_ENCRYPT_RESP;
}
break;
default:
return ERR_UNPACK_ENCRYPT_RESP;
break;
}
return 0;
}
/* push_data (S->C) */
int32_t UnpackPushdata(EdpPacket* pkg, int8_t** src_devid, int8_t** data, uint32_t* data_len)
{
uint32_t remainlen;
if (ReadRemainlen(pkg, &remainlen))
return ERR_UNPACK_PUSHD_REMAIN;
if (ReadStr(pkg, src_devid))
return ERR_UNPACK_PUSHD_DEVID;
remainlen -= (2 + strlen((const char *)(*src_devid)));
if (ReadBytes(pkg, (uint8_t**)data, remainlen))
return ERR_UNPACK_PUSHD_DATA;
*data_len = remainlen;
my_assert(pkg->_read_pos == pkg->_write_pos);
return 0;
}
/* connect_resp (S->C)*/
int32_t UnpackConnectResp(EdpPacket* pkg)
{
uint8_t flag, rtn;
uint32_t remainlen;
if (ReadRemainlen(pkg, &remainlen))
return ERR_UNPACK_CONNRESP_REMAIN;
if (ReadByte(pkg, &flag))
return ERR_UNPACK_CONNRESP_FLAG;
if (ReadByte(pkg, &rtn))
return ERR_UNPACK_CONNRESP_RTN;
my_assert(pkg->_read_pos == pkg->_write_pos);
return (int32_t)rtn;
}
/* push_data (S->C) */
int32 UnpackPushdata(EdpPacket* pkg, char** src_devid, char** data, uint32* data_len)
{
uint32 remainlen;
if (ReadRemainlen(pkg, &remainlen))
return ERR_UNPACK_PUSHD_REMAIN;
if (ReadStr(pkg, src_devid))
return ERR_UNPACK_PUSHD_DEVID;
remainlen -= (2 + mystrlen(*src_devid));
if (ReadBytes(pkg, (uint8**)data, remainlen))
return ERR_UNPACK_PUSHD_DATA;
*data_len = remainlen;
//assert(pkg->_read_pos == pkg->_write_pos);
return 0;
}
int32_t UnpackSavedataAck(EdpPacket* pkg, int8_t** json_ack)
{
uint32_t remainlen = 0;
uint8_t flag = 0;
uint16_t json_len = 0;
if (ReadRemainlen(pkg, &remainlen))
return ERR_UNPACK_SAVEDATA_ACK;
if (ReadByte(pkg, &flag))
return ERR_UNPACK_SAVEDATA_ACK;
if (ReadUint16(pkg, &json_len))
return ERR_UNPACK_SAVEDATA_ACK;
if (ReadBytes(pkg, (uint8_t**)(json_ack), json_len))
return ERR_UNPACK_SAVEDATA_ACK;
return 0;
}
int32_t UnpackCmdReq(EdpPacket* pkg, int8_t** cmdid, uint16_t* cmdid_len,
int8_t** req, uint32_t* req_len)
{
uint32 remainlen;
int32_t rc;
if (ReadRemainlen(pkg, &remainlen))
return ERR_UNPACK_CMDREQ;
rc = ReadUint16(pkg, cmdid_len);
if (rc)
return rc;
if (ReadBytes(pkg, (uint8_t**)cmdid, *cmdid_len))
return ERR_UNPACK_CMDREQ;
rc = ReadUint32(pkg, req_len);
if (rc)
return rc;
if (ReadBytes(pkg, (uint8_t**)req, *req_len))
return ERR_UNPACK_CMDREQ;
my_assert(pkg->_read_pos == pkg->_write_pos);
return 0;
}
/* save_data (S->C) */
int32_t UnpackSavedata(EdpPacket* pkg, int8_t** src_devid, uint8_t* jb_flag)
{
uint32_t remainlen;
uint8_t ta_flag;
if (ReadRemainlen(pkg, &remainlen))
return ERR_UNPACK_SAVED_REMAIN;
/* translate address flag */
if (ReadByte(pkg, &ta_flag))
return ERR_UNPACK_SAVED_TANSFLAG;
if (ta_flag == 0x80)
{
if (ReadStr(pkg, src_devid))
return ERR_UNPACK_SAVED_DEVID;
}
else
{
*src_devid = 0;
}
/* json or bin */
if (ReadByte(pkg, jb_flag))
return ERR_UNPACK_SAVED_DATAFLAG;
return 0;
}
/* connect_resp (S->C)*/
int32 UnpackConnectResp(EdpPacket* pkg)
{
uint8 flag, rtn;
uint32 remainlen;
if (ReadRemainlen(pkg, &remainlen))
{
return ERR_UNPACK_CONNRESP_REMAIN;
}
if (ReadByte(pkg, &flag))
{
return ERR_UNPACK_CONNRESP_FLAG;
}
if (ReadByte(pkg, &rtn))
{
return ERR_UNPACK_CONNRESP_RTN;
}
return (int32)rtn;
}
