使用异或运算对数据及文件进行加密处理

typedef struct CRYPT_BLOCK {
　　DWORD    dwSize;    // Data的
　　DWORD    dwKey;    // 密钥 循环使用DWORD的每个字节来进行加密 详情见XorEncrypt
　　char    chData[1];    // 加密后的数据
} CRYPT_BLOCK, *PCRYPT_BLOCK;

typedef boost::shared_ptr<Json::Value> JsonSharedPtr;

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

  c = a^b;

  c = c^b;

  c == a;

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

bool XorEncrypt(const char* pKey, DWORD dwCbKey, const char* pIn, DWORD dwCbSize, char* pOut)
{
　　if (pIn == NULL || pOut == NULL || pKey == NULL) {
　　　　return false;
　　}

　　for (DWORD i = 0; i < dwCbSize; ++i) {
　　　　pOut[i] = pIn[i] ^ pKey[i % dwCbKey];
　　}

　　return true;
}

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

加密函数：

vector<char> Encrypt(const vector<char> &vecPlainData)
{
    vector<char> vecCryptedData;

    do {

        if (vecPlainData.empty()) {
            break;
        }
        
        if (UINT_MAX - vecPlainData.size() < sizeof(CRYPT_BLOCK) - 1) {
            //溢出
            break;
        }
        
        //文件里的加密信息是分成一个一个数据块CRYPT_BLOCK存放的
        //只是用异或简单加密一下，具体加密流程见XorEncrypt函数
        DWORD dwCryptBlockSize = sizeof(CRYPT_BLOCK) - 1 + vecPlainData.size();

        vecCryptedData.resize(dwCryptBlockSize);
        PCRYPT_BLOCK CryptedBlock = (PCRYPT_BLOCK)&vecCryptedData[0];
        CryptedBlock->dwKey = GenerateKey();
        CryptedBlock->dwSize = vecPlainData.size();

        bool bOk = XorEncrypt((char*)&CryptedBlock->dwKey, sizeof CryptedBlock->dwKey, &vecPlainData[0], vecPlainData.size(), CryptedBlock->chData);
        if (!bOk) {
            vecCryptedData.clear();
        }
    } while (false);

    return vecCryptedData;
}

解密函数：

vector<char> Decrypt(const vector<char> &vecCryptedData)
{
    PCRYPT_BLOCK pCryptedBlock = NULL;
    vector<char> vecPlainData;

    do {
        if (vecCryptedData.size() < sizeof *pCryptedBlock) {
            break;
        }

        pCryptedBlock = (PCRYPT_BLOCK)&vecCryptedData[0];
        
        if (UINT_MAX - pCryptedBlock->dwSize < sizeof *pCryptedBlock - 1) {
            //溢出
            break;
        }
        //运算符优先级 sizeof > 加减 > 不等
        if (pCryptedBlock->dwSize + sizeof *pCryptedBlock - 1 != vecCryptedData.size()) {
            break;
        }

        vecPlainData.resize(pCryptedBlock->dwSize);
        bool ok = XorEncrypt((char *)&pCryptedBlock->dwKey, sizeof pCryptedBlock->dwKey, pCryptedBlock->chData, pCryptedBlock->dwSize, &vecPlainData[0]);
        if (!ok) {
            vecPlainData.clear();
        }

    } while (false);

    return vecPlainData;
}

生成Key：

BYTE CHipsLogQueue::RandomByte()
{
    unsigned int random;
    rand_s(&random);
    return BYTE(random);
}

DWORD CHipsLogQueue::GenerateKey()
{
    DWORD Key = 0;
    
    for (int i = 0; i < 4; ++i) {
        ((BYTE *)(&Key))[i] = RandomByte();
    }
    
    return Key;
}