新鲜出炉动态加解密,纯手工打造c++版.

sankeyou

动态加解密就是说同样的内容,每次加密的结果都不一样,但是还能解出来

                               
登录/注册后可看大图

例子程序使用vc++6.0编写

支持任何数据动态加解密,如:字符串,结构体等.我目前用于封包加解密中.

加密函数:

1. 
   
2. // 参数1:加密后的字符串存放位置
   
3. // 参数2:待加密明文
   
4. // 参数3:待加密明文长度
   
5. // 参数4:用作加密的key
   
6. // 返回值:加密后的字符串长度
   
7. int Encryption(char *pDst, const char *pSrc, int nSrcLen,
   
8.                            const char *pKey = "ssdfj23@#$^**&)(~!!~!~!~!~!sd;lkf")
   
9. {
   
10.     if (pDst == NULL || pSrc == NULL || nSrcLen == 0)
    
11.     {
    
12.         return 0;
    
13.     }
    
14. 
    
15.     // 密匙长度
    
16.     int nKeyLen = strlen(pKey);
    
17. 
    
18.     // 新的密匙
    
19.     char *pNewKey = (char *)malloc(nKeyLen + sizeof(char));
    
20.     if (pNewKey == NULL)
    
21.     {
    
22.         return 0;
    
23.     }
    
24. 
    
25.     memset(pNewKey, '\0', nKeyLen + sizeof(char));
    
26.     memcpy(pNewKey, pKey, nKeyLen);
    
27. 
    
28.     // 启动时间
    
29.     int nStartTime = GetTickCount();
    
30. 
    
31. 
    
32.     // 密匙时间
    
33.     int nKeyTime = nStartTime;
    
34. 
    
35.     // 取2 - 255 之间的随机数
    
36.     srand((unsigned int)time(0));
    
37.     int nRand = 2 + rand() % (255 - 2);
    
38. 
    
39.     int i = 0;
    
40.     int nCount = 0;
    
41. 
    
42.     // nKeyTime 每个字节 = nStartTime[i] ^ nRand, 产生一个新的 nKeyTime
    
43.     for (i = 0; i < 4; i++)
    
44.     {
    
45.         ((char*)&nKeyTime)[i] = ((char*) & nStartTime)[i] ^ nRand;
    
46.     }
    
47. 
    
48.     // 把 pNewKey 和 nKeyTime 每个字节顺序 ^, 产生一个新的key
    
49.     for (i = 0; i < nKeyLen; i++)
    
50.     {
    
51.         pNewKey[i] ^= ((char*) & nKeyTime)[nCount];
    
52. 
    
53.         nCount++;
    
54.         if (nCount > 3)
    
55.         {
    
56.             nCount = 0;
    
57.         }
    
58.     }
    
59. 
    
60.     for (i = 0; i < nSrcLen; i++)
    
61.     {
    
62. 
    
63.         pDst[i + sizeof(nKeyTime) + sizeof(nRand)] = pSrc[i];
    
64.         // 当前字节先和 key 异或一遍
    
65.         for (int j = 0; j < nKeyLen; j++)
    
66.         {
    
67.             pDst[i + sizeof(nKeyTime) + sizeof(nRand)] ^= pNewKey[j];
    
68.         }
    
69. 
    
70.         // 在和启动时间当前计数异或一遍
    
71.         pDst[i + sizeof(nKeyTime) + sizeof(nRand)] ^= ((char*) & nStartTime)[nCount];
    
72. 
    
73.         nCount++;
    
74.         if (nCount > 3)
    
75.         {
    
76.             nCount = 0;
    
77.         }
    
78.     }
    
79. 
    
80.     nRand = ~nRand;
    
81. 
    
82.     nRand ^= nKeyTime;
    
83. 
    
84.     // nRand
    
85.     memcpy(pDst, (char *)&nRand, sizeof(nRand));
    
86. 
    
87.     // ## nKeyTime
    
88.     memcpy(pDst + sizeof(nRand), (char *)&nKeyTime, sizeof(nKeyTime));
    
89. 
    
90. 
    
91.     if (pNewKey != NULL)
    
92.     {
    
93.         free(pNewKey);
    
94.         pNewKey = NULL;
    
95.     }
    
96. 
    
97.     return nSrcLen + sizeof(nKeyTime) + sizeof(nRand);
    
98. }
    

复制代码

解密函数:

1. 
   
2. // 参数1:解密后的字符串存放位置
   
3. // 参数2:待解密密文
   
4. // 参数3:待解密密文长度
   
5. // 参数4:用作解密的key
   
6. // 返回值:解密后的字符串长度
   
7. int Decryption(char *pDst, const char *pSrc, int nSrcLen,
   
8.                            const char *pKey = "ssdfj23@#$^**&)(~!!~!~!~!~!sd;lkf")
   
9. {
   
10. 
    
11.     if (pDst == NULL || pSrc == NULL || nSrcLen < 9)
    
12.     {
    
13.         return 0;
    
14.     }
    
15. 
    
16.     // 密匙长度
    
17.     int nKeyLen = strlen(pKey);
    
18. 
    
19.     // 取出那个随机数
    
20.     int nRand = *(int *)pSrc ^ *(int *)(pSrc + 4);
    
21.     nRand = ~nRand;
    
22. 
    
23.     // 新的源内容
    
24.     char *pNewSrc = (char *)malloc(nSrcLen + sizeof(char));
    
25.     if (pNewSrc == NULL)
    
26.     {
    
27.         return 0;
    
28.     }
    
29. 
    
30.     memset(pNewSrc, '\0', nSrcLen + sizeof(char));
    
31.     memcpy(pNewSrc, pSrc + 4, nSrcLen);
    
32. 
    
33.     int i = 0;
    
34.     int nKeyTime = 0, nKeyTime2 = 0;
    
35. 
    
36.     for (i = 0; i < 4; i++)
    
37.     {
    
38.         ((char *)&nKeyTime)[i] = pNewSrc[i];
    
39.         ((char *)&nKeyTime2)[i] = pNewSrc[i] ^ nRand;
    
40.     }
    
41. 
    
42.     int nNewSrcLen = nSrcLen - 8;
    
43.     int nCount = 0;
    
44. 
    
45.     memset(pNewSrc, '\0', nSrcLen + sizeof(char));
    
46.     memcpy(pNewSrc, pSrc + 8, nNewSrcLen);
    
47. 
    
48.     // 新的密匙
    
49.     char *pNewKey = (char *)malloc(nKeyLen + sizeof(char));
    
50.     if (pNewKey == NULL)
    
51.     {
    
52.         return 0;
    
53.     }
    
54.     memset(pNewKey, '\0', nKeyLen + sizeof(char));
    
55.     memcpy(pNewKey, pKey, nKeyLen);
    
56. 
    
57.     for (i = 0; i < nKeyLen; i++)
    
58.     {
    
59.         pNewKey[i] ^= ((char *) & nKeyTime)[nCount];
    
60. 
    
61.         nCount++;
    
62.         if (nCount > 3)
    
63.         {
    
64.             nCount = 0;
    
65.         }
    
66.     }
    
67. 
    
68. 
    
69.     for (i = 0; i < nNewSrcLen; i++)
    
70.     {
    
71.         pDst[i] = pNewSrc[i] ^((char*) & nKeyTime2)[nCount];
    
72. 
    
73.         for (int j = 0; j < nKeyLen; j++)
    
74.         {
    
75.             pDst[i] ^= pNewKey[j];
    
76.         }
    
77. 
    
78.         nCount++;
    
79.         if (nCount > 3)
    
80.         {
    
81.             nCount = 0;
    
82.         }
    
83. 
    
84.     }
    
85. 
    
86.     if (pNewSrc != NULL)
    
87.     {
    
88.         free(pNewSrc);
    
89.         pNewSrc = NULL;
    
90.     }
    
91. 
    
92.     if (pNewKey != NULL)
    
93.     {
    
94.         free(pNewKey);
    
95.         pNewKey = NULL;
    
96.     }
    
97. 
    
98.     return nNewSrcLen;
    
99. }
    

复制代码

使用例子:

游客，如果您要查看本帖隐藏内容请回复

PS:加解密的执行效率,取决于Key的长度,key越长就越慢,不可不免,但是这2个函数,效率依然很高,key长一些就相对安全一些.
PS:加密后存储的buffer要比加密前的大8个字节,解密后的buffer比解密前的可以小8个字节.




delphi版本连接 http://bbs.fishc.com/forum.php?mod=viewthread&tid=12970&page=1&extra=#pid124313

ever.g

感谢分享 抽时间看一下

ccqiji

看下吧
貌似就用个随机
密码最好绑定下关键函数
只有密码正确关键函数
才能正确解密出来 程序才能跑

ccqiji

看下吧
貌似就用个随机
密码最好绑定下关键函数
只有密码正确关键函数
才能正确解密出来 程序才能跑

bafengao

好东东 有本事

wqlovt

很不错哦~~！！

咴涩丶头像

楼主分享一下

ChinaOne

多谢分享哦

xiao7

多谢分享！

loo

:lol:

人造人

看看

ybhacker

测试测试测试测试

791026701

谢谢  楼主

沧桑

  楼主 这需要学习什么》？

wuhuei153

看看能下载吗

zhouxcpython

谢谢分享