【加密】Cocos2d-x PNG圖片資源加密（修改版）

峻峰飛陽發表於2017-03-13
加密

【說明】

這篇文章是對上一篇 【Cocos2d-x PNG圖片資源加密】的補充和擴充套件，那篇文章轉自【舊時塵安】的部落格，文中已經對原理和使用講解的很清晰，這裡只是根據我自己的使用情況做一些小小的功能擴充套件，也是自己做個整理，以便日後使用。如有侵權，請聯絡刪除。


【連結】

原文地址：http://www.cnblogs.com/zhangpanyi/p/4560297.html

原始工程：https://github.com/zhangpanyi/EncryptPNG


【使用】

修改後的使用有所調整，原文的使用更簡潔，這裡主要是依照我個人的習慣作出的調整。我在程式碼中新增了設定金鑰和副檔名的介面。

1. 在 cocos 目錄下新建資料夾 ext ，將 CCAES.cpp、CCAES.h、CCDecryptImage.cpp、CCDecryptImage.h 拷貝到其中。

2. 在Xcode專案中引用 ext 目錄。

注：這裡可能會報錯，為此我耽誤了半天，結果居然是Xcode沒有自動引用導致的，我已記錄到 【這裡】。

3. Android專案需要修改 cocos/Android.mk 檔案，將兩個cpp檔案新增進去即可。

4. 在 CCImage 中呼叫解密程式碼，方法與原文一樣，這裡略有修改，程式碼見附錄。

注：我將對 CCDecryptImage.h 的引用放在了 CCImage.h ，是為了在專案中設定金鑰時不需要再引用此標頭檔案。

5. 在專案中設定金鑰和副檔名，我是在 AppDelegate.cpp 中設定。

注：如果修改副檔名，需要加密端也做修改，保證兩邊副檔名一致。

[cpp] view plain copy
  1. // 設定金鑰  
  2. const ext::aes_key key = {0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39};  
  3. ext::DecryptImageConfig(key, ".epng");  

【程式碼】

[cpp] view plain copy
  1. CCImage.cpp  

[cpp] view plain copy
  1. bool Image::initWithImageFile(const std::string& path)  
  2. {  
  3.     ......  
  4.   
  5.     if (!data.isNull())  
  6.     {  
  7.         // 圖片檔案解密  
  8.         if (ext::AnalyzeExtension(path)[1] == ext::TARGET_EXTENSION)  
  9.         {  
  10.             auto image_data = ext::DecryptImage(path, data);  
  11.             ret = initWithImageData(&image_data[0], image_data.size());  
  12.         }  
  13.         else  
  14.         {  
  15.             ret = initWithImageData(data.getBytes(), data.getSize());  
  16.         }  
  17.     }  
  18. #endif // EMSCRIPTEN  
  19.   
  20.     return ret;  
  21. }  
  22.   
  23. bool Image::initWithImageFileThreadSafe(const std::string& fullpath)  
  24. {  
  25.     ......  
  26.   
  27.     if (!data.isNull())  
  28.     {  
  29.         // 圖片檔案解密  
  30.         if (ext::AnalyzeExtension(fullpath)[1] == ext::TARGET_EXTENSION)  
  31.         {  
  32.             auto image_data = ext::DecryptImage(fullpath, data);  
  33.             ret = initWithImageData(&image_data[0], image_data.size());  
  34.         }  
  35.         else  
  36.         {  
  37.             ret = initWithImageData(data.getBytes(), data.getSize());  
  38.         }  
  39.     }  
  40.   
  41.     return ret;  
  42. }  

[cpp] view plain copy
  1. <span style="font-family: Arial, Helvetica, sans-serif;">CCDecryptImage.h</span>  

[cpp] view plain copy
  1. #ifndef __CC_DECRYPT_IMAGE_H__  
  2. #define __CC_DECRYPT_IMAGE_H__  
  3.   
  4. #include <array>  
  5. #include <vector>  
  6. #include "CCData.h"  
  7. #include "CCAES.h"  
  8.   
  9. namespace ext  
  10. {  
  11.     /* 解密副檔名 */  
  12.     static std::string TARGET_EXTENSION = ".epng";  
  13.       
  14.     /* 解密金鑰 */  
  15.     static aes_key SECRET_KEY = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 };  
  16.       
  17.     /** 
  18.      * 設定解密祕鑰 
  19.      * @param key   祕鑰（AES的16位祕鑰） 
  20.      * @param exten 副檔名（需要解密的副檔名，如".png"） 
  21.      */  
  22.     void DecryptImageConfig(const aes_key &key, const std::string &exten = TARGET_EXTENSION);  
  23.       
  24.     /** 
  25.      * 解密圖片檔案（在CCImage中呼叫） 
  26.      * @param filename 檔名稱 
  27.      * @param data 檔案資料 
  28.      */  
  29.     std::vector<unsigned char> DecryptImage(const std::string &filename, cocos2d::Data &data);  
  30.       
  31.     /** 
  32.      * 分解檔名的副檔名（在CCImage中呼叫） 
  33.      * @param file_path 檔名 
  34.      */  
  35.     std::array<std::string, 2> AnalyzeExtension(const std::string &file_path);  
  36.       
  37. }  
  38.   
  39. #endif  

[cpp] view plain copy
  1. CCDecryptImage.cpp  
[cpp] view plain copy
  1. #include "CCDecryptImage.h"  
  2.   
  3. #include <sstream>  
  4. #include "ccMacros.h"  
  5.   
  6. #if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)  
  7. #include <WinSock.h>  
  8. #pragma comment(lib, "ws2_32.lib")  
  9. #elif (CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)  
  10. #include <netinet/in.h>  
  11. #endif  
  12.   
  13. namespace ext  
  14. {  
  15.     /* CRC碼長度 */  
  16.     static const uint32_t CRC_SIZE = 4;  
  17.   
  18.     /* 檔案頭部 */  
  19.     static const unsigned char HEAD_DATA[] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };  
  20.   
  21.     /* IEND CRC碼 */  
  22.     static const unsigned char IEND_DATA[] = { 0xae, 0x42, 0x60, 0x82 };  
  23.   
  24.     /* 資料塊頭部（用於驗證解密是否成功） */  
  25.     static const unsigned char BLOCK_HEAD[] = { 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x50, 0x4e, 0x47 };  
  26.   
  27. #pragma pack(push, 1)  
  28.   
  29.     struct Block  
  30.     {  
  31.         char name[4];  
  32.         uint32_t pos;  
  33.         uint32_t size;  
  34.     };  
  35.   
  36.     struct IHDRBlock  
  37.     {  
  38.         Block block;  
  39.         char data[13 + CRC_SIZE];  
  40.     };  
  41.   
  42. #pragma pack(pop)  
  43.   
  44.     /* 解析副檔名 */  
  45.     std::array<std::string, 2> AnalyzeExtension(const std::string &file_path)  
  46.     {  
  47.         std::string::size_type pos = file_path.rfind('.');  
  48.         std::array<std::string, 2> text;  
  49.         if (std::string::npos != pos)  
  50.         {  
  51.             text[1] = file_path.substr(pos);  
  52.             text[0] = file_path.substr(0, pos);  
  53.         }  
  54.         else  
  55.         {  
  56.             text[0] = file_path;  
  57.         }  
  58.         return text;  
  59.     }  
  60.   
  61.     template <int _Value, typename _Stream>  
  62.     std::array<char, _Value> ReadSome(_Stream &stream)  
  63.     {  
  64.         std::array<char, _Value> buffer;  
  65.         for (unsigned int i = 0; i < _Value; ++i) buffer[i] = stream.get();  
  66.         return buffer;  
  67.     }  
  68.   
  69.     /* 解密塊 */  
  70.     void DecryptBlock(std::stringstream &ss, const aes_key &key)  
  71.     {  
  72.         const std::streamoff contents_size = ss.tellp() - ss.tellg();  
  73.         const uint32_t block_size = (uint32_t)(contents_size + AES_BLOCK_SIZE - contents_size % AES_BLOCK_SIZE);  
  74.         std::vector<uint8_t> buffer;  
  75.         buffer.resize(block_size);  
  76.         for (uint32_t i = 0; i < contents_size; ++i) buffer[i] = ss.get();  
  77.         AES::DecryptData(&buffer[0], block_size, key);  
  78.         ss.seekg(0); ss.seekp(0);  
  79.         for (uint32_t i = 0; i < block_size; ++i) ss.put(buffer[i]);  
  80.     }  
  81.   
  82.     /* 解密圖片檔案 */  
  83.     std::vector<unsigned char> DecryptImage(const std::string &filename, cocos2d::Data &data)  
  84.     {  
  85.         CCAssert(!data.isNull(), "data is null!");  
  86.   
  87.         // 獲取資料塊資訊位置  
  88.         const uint32_t block_start_pos = ntohl(*reinterpret_cast<uint32_t *>(data.getBytes() + data.getSize() - sizeof(uint32_t)));  
  89.   
  90.         // 獲取資料塊資訊  
  91.         std::stringstream block_info;  
  92.         for (uint32_t i = block_start_pos; i < data.getSize() - sizeof(uint32_t); ++i)  
  93.         {  
  94.             block_info.put(*(data.getBytes() + i));  
  95.         }  
  96.   
  97.         // 解密資料塊資訊  
  98.         DecryptBlock(block_info, SECRET_KEY);  
  99.   
  100.         // 驗證資料塊資訊是否解密成功  
  101.         auto block_head = ReadSome<sizeof(BLOCK_HEAD)>(block_info);  
  102.         for (unsigned int i = 0; i < block_head.size(); ++i)  
  103.         {  
  104.             if (block_head[i] != BLOCK_HEAD[i])  
  105.             {  
  106.                 CCAssert(false, "the key is wrong!");  
  107.             }  
  108.         }  
  109.   
  110.         // 寫入檔案頭資訊  
  111.         std::vector<unsigned char> image_data;  
  112.         image_data.reserve(data.getSize());  
  113.         for (auto ch : HEAD_DATA) image_data.push_back(ch);  
  114.   
  115.         // 寫入資料塊資訊  
  116.         while (true)  
  117.         {  
  118.             Block block;  
  119.             memcpy(&block, &(ReadSome<sizeof(Block)>(block_info)[0]), sizeof(Block));  
  120.             if (block_info.eof())  
  121.             {  
  122.                 CCAssert(false, "");  
  123.                 CCLOG("the %s file format error!", filename.c_str());  
  124.             }  
  125.   
  126.             // 寫入資料塊長度和名稱  
  127.             char size_buffer[sizeof(block.size)];  
  128.             memcpy(size_buffer, &block.size, sizeof(size_buffer));  
  129.             for (auto ch : size_buffer) image_data.push_back(ch);  
  130.             for (auto ch : block.name) image_data.push_back(ch);  
  131.   
  132.             block.pos = ntohl(block.pos);  
  133.             block.size = ntohl(block.size);  
  134.   
  135.             char block_name[sizeof(block.name) + 1] = { 0 };  
  136.             memcpy(block_name, block.name, sizeof(block.name));  
  137.             if (strcmp(block_name, "IHDR") == 0)  
  138.             {  
  139.                 IHDRBlock ihdr;  
  140.                 memcpy(&ihdr, &block, sizeof(Block));  
  141.                 memcpy(((char *)&ihdr) + sizeof(Block), &ReadSome<sizeof(IHDRBlock) - sizeof(Block)>(block_info)[0], sizeof(IHDRBlock) - sizeof(Block));  
  142.                 for (auto ch : ihdr.data) image_data.push_back(ch);  
  143.             }  
  144.             else if (strcmp(block_name, "IEND") == 0)  
  145.             {  
  146.                 for (auto ch : IEND_DATA) image_data.push_back(ch);  
  147.                 CCLOG("decrypt %s success!", filename.c_str());  
  148.                 break;  
  149.             }  
  150.             else  
  151.             {  
  152.                 for (uint32_t i = 0; i < block.size + CRC_SIZE; ++i)  
  153.                 {  
  154.                     image_data.push_back(*(data.getBytes() + block.pos + i));  
  155.                 }  
  156.             }  
  157.         }  
  158.         return image_data;  
  159.     }  
  160.       
  161.     /* 配置解密祕鑰和副檔名 */  
  162.     void DecryptImageConfig(const aes_key &key, const std::string &exten)  
  163.     {  
  164.         SECRET_KEY = key;  
  165.         TARGET_EXTENSION = exten;  
  166.     }  
  167. }  

相關文章