解密 char转换为json

1 typedef struct CRYPT_BLOCK {
2 　　DWORD    dwSize;    // Data的
3 　　DWORD    dwKey;    // 密钥 循环使用DWORD的每个字节来进行加密 详情见XorEncrypt
4 　　char    chData[1];    // 加密后的数据
5 } CRYPT_BLOCK, *PCRYPT_BLOCK;
6 
7 typedef boost::shared_ptr<Json::Value> JsonSharedPtr;

一个数异或另一个数两次后，该数保持不变。即：

c = a^b;

c = c^b;

c == a;

这一规律就是使用异或运算对数据及文件进行加密处理的基本原理。

 1 bool XorEncrypt(const char* pKey, DWORD dwCbKey, const char* pIn, DWORD dwCbSize, char* pOut)
 2 {
 3 　　if (pIn == NULL || pOut == NULL || pKey == NULL) {
 4 　　　　return false;
 5 　　}
 6 
 7 　　for (DWORD i = 0; i < dwCbSize; ++i) {
 8 　　　　pOut[i] = pIn[i] ^ pKey[i % dwCbKey];
 9 　　}
10 
11 　　return true;
12 }

pKey为密钥数据指针，dwCbKey为密钥数据长度，pIn为需要加密的数据指针，dwCbSize为需要加密的数据长度，pOut为加密后数据指针

加密函数：

 1 vector<char> Encrypt(const vector<char> &vecPlainData)
 2 {
 3     vector<char> vecCryptedData;
 4 
 5     do {
 6 
 7         if (vecPlainData.empty()) {
 8             break;
 9         }
10         
11         if (UINT_MAX - vecPlainData.size() < sizeof(CRYPT_BLOCK) - 1) {
12             //溢出
13             break;
14         }
15         
16         //文件里的加密信息是分成一个一个数据块CRYPT_BLOCK存放的
17         //只是用异或简单加密一下，具体加密流程见XorEncrypt函数
18         DWORD dwCryptBlockSize = sizeof(CRYPT_BLOCK) - 1 + vecPlainData.size();
19 
20         vecCryptedData.resize(dwCryptBlockSize);
21         PCRYPT_BLOCK CryptedBlock = (PCRYPT_BLOCK)&vecCryptedData[0];
22         CryptedBlock->dwKey = GenerateKey();
23         CryptedBlock->dwSize = vecPlainData.size();
24 
25         bool bOk = XorEncrypt((char*)&CryptedBlock->dwKey, sizeof CryptedBlock->dwKey, &vecPlainData[0], vecPlainData.size(), CryptedBlock->chData);
26         if (!bOk) {
27             vecCryptedData.clear();
28         }
29     } while (false);
30 
31     return vecCryptedData;
32 }

解密函数：

 1 vector<char> Decrypt(const vector<char> &vecCryptedData)
 2 {
 3     PCRYPT_BLOCK pCryptedBlock = NULL;
 4     vector<char> vecPlainData;
 5 
 6     do {
 7         if (vecCryptedData.size() < sizeof *pCryptedBlock) {
 8             break;
 9         }
10 
11         pCryptedBlock = (PCRYPT_BLOCK)&vecCryptedData[0];
12         
13         if (UINT_MAX - pCryptedBlock->dwSize < sizeof *pCryptedBlock - 1) {
14             //溢出
15             break;
16         }
17         //运算符优先级 sizeof > 加减 > 不等
18         if (pCryptedBlock->dwSize + sizeof *pCryptedBlock - 1 != vecCryptedData.size()) {
19             break;
20         }
21 
22         vecPlainData.resize(pCryptedBlock->dwSize);
23         bool ok = XorEncrypt((char *)&pCryptedBlock->dwKey, sizeof pCryptedBlock->dwKey, pCryptedBlock->chData, pCryptedBlock->dwSize, &vecPlainData[0]);
24         if (!ok) {
25             vecPlainData.clear();
26         }
27 
28     } while (false);
29 
30     return vecPlainData;
31 }

生成Key：

 1 BYTE CHipsLogQueue::RandomByte()
 2 {
 3     unsigned int random;
 4     rand_s(&random);
 5     return BYTE(random);
 6 }
 7 
 8 DWORD CHipsLogQueue::GenerateKey()
 9 {
10     DWORD Key = 0;
11     
12     for (int i = 0; i < 4; ++i) {
13         ((BYTE *)(&Key))[i] = RandomByte();
14     }
15     
16     return Key;
17 }

来源：https://www.cnblogs.com/yapp/p/11975362.html

标签

char

char函数

dword

sizeof