你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

(已解决)遇到一个看不懂的函数,感觉自己傻乎乎。。。

[复制链接]
与龙共舞 提问时间:2018-8-1 09:17 /
本帖最后由 与龙共舞 于 2018-8-15 11:38 编辑

以前小公司嵌入式终端和平台收发数据都是明文,现在我司也加密了。网络数据加密,蓝牙数据加密,昨天看到刷卡RFID的数据也是加密了。
函数:
  1. void DecryStr(unsigned char* str,unsigned char* key,unsigned char* presult)//解密函数8个字节
  2. {
  3.   unsigned char subkey[8][8];
  4.   makeKey(key, subkey);
  5.   desData(1,str,presult,subkey);
  6.   conversePermutation(presult);
  7. }
复制代码
对一个str的解密,第一步是做钥匙(能看懂)第二步是解密(能看懂)主要是利用C=A^B加密 然后C^B就回到A吧。所以A是明文,B是秘钥,C是密文(我自己理解的ASE算法)
第三步就看不懂了,这个是干啥呀,拿出来问问:
  1. void conversePermutation(unsigned char* inData)
  2. {
  3.         unsigned char newData[8]={0,0,0,0,0,0,0,0};
  4.         int i;
  5.         for(i=0;i<64;i++)
  6.         {
  7.                 if(  (      inData[BitCP[i]>>3]   &     (1<<(7-(BitCP[i]&7)))        )!=0   )
  8.                         newData[i>>3]=newData[i>>3]|(1<<(7-(i&7)));
  9.         }
  10.         for(i=0;i<8;i++)
  11.         {
  12.                 inData[i]=newData[i];
  13.         }
  14. }
复制代码
看上去就是对一个string倒腾。然后用到了一个常量的数组。
  1. const unsigned char BitCP[64] =
  2. { 36, 7, 40, 60, 43, 19, 47, 23,
  3. 34, 4, 39, 8, 42, 26, 46, 29,
  4. 33, 1, 38, 16, 57, 18, 51, 28,
  5. 32, 0, 37, 12, 56, 10, 45, 21,
  6. 53, 3, 6, 61, 44, 54, 5, 35,
  7. 15, 48, 55, 58, 20, 22, 31, 25,
  8. 9, 41, 13, 14, 59, 30, 2, 63,
  9. 11, 27, 17, 49, 62, 24, 52, 50 };
复制代码
这个数组我看了是0--63的乱序排列。

问题1:这个函数啥意思--------------------具体做啥暂时不知道 是解密的吧 还有多学点english
问题2:string经过这个函数以后就变化了,用什么办法可以还原呢----------有的 看配套的函数
++++++++++++++++++++20180815解答+++++++++++++
昨天看微信文章DES 和3DES 看到图片列在一起  初始转置表--终止转职表   我有突然想起我的这个问题,
QQ截图20180815113600.jpg
解铃还需系的人呀 工程里面果然我也找到了它的配偶,下面是我自己的加密解密,还是不知道叫什么名字。。。。DES吧
  1. #include<stdio.h>
  2. #include<string.h>
  3. typedef unsigned char  uint8_t;
  4. typedef unsigned short uint16_t;

  5. const unsigned char BitIP[64] =
  6. { 25, 17, 54, 33, 9, 38, 34, 1,
  7. 11, 48, 29, 56, 27, 50, 51, 40,
  8. 19, 58, 21, 5, 44, 31, 45, 7,
  9. 61, 47, 13, 57, 23, 15, 53, 46,
  10. 24, 16, 8, 39, 0, 26, 18, 10,
  11. 2, 49, 12, 4, 36, 30, 14, 6,
  12. 41, 59, 63, 22, 62, 32, 37, 42,
  13. 28, 20, 43, 52, 3, 35, 60, 55 };

  14. const unsigned char BitCP[64] =
  15. { 36, 7, 40, 60, 43, 19, 47, 23,
  16. 34, 4, 39, 8, 42, 26, 46, 29,
  17. 33, 1, 38, 16, 57, 18, 51, 28,
  18. 32, 0, 37, 12, 56, 10, 45, 21,
  19. 53, 3, 6, 61, 44, 54, 5, 35,
  20. 15, 48, 55, 58, 20, 22, 31, 25,
  21. 9, 41, 13, 14, 59, 30, 2, 63,
  22. 11, 27, 17, 49, 62, 24, 52, 50 };
  23. void initPermutation(unsigned char* inData)
  24. {

  25.         unsigned char newData[8]={0,0,0,0,0,0,0,0};
  26.         int i;
  27.         for(i=0;i<64;i++)
  28.         {
  29.                 if((inData[BitIP[i]>>3]&(1<<(7-(BitIP[i]&7))))!=0)
  30.                         newData[i>>3]=newData[i>>3]|(1<<(7-(i&7)));
  31.         }
  32.         for(i=0;i<8;i++)
  33.         {
  34.                 inData[i]=newData[i];
  35.         }

  36.        
  37. }

  38. void conversePermutation(unsigned char* inData)
  39. {
  40.         unsigned char newData[8]={0,0,0,0,0,0,0,0};
  41.         int i;
  42.         for(i=0;i<64;i++)
  43.         {
  44.                 if(  (      inData[BitCP[i]>>3]   &     (1<<(7-(BitCP[i]&7)))        )!=0   )
  45.                         newData[i>>3]=newData[i>>3]|(1<<(7-(i&7)));
  46.         }
  47.         for(i=0;i<8;i++)
  48.         {
  49.                 inData[i]=newData[i];
  50.         }
  51. }

  52. unsigned char str[8]={0xF6,0x56,0x21,0x33,0x9E,0x25,0x29,0xD3};

  53. int main(void)
  54. {
  55.         int i;
  56.         for(i=0;i<8;i++)          printf("%02X  ",str[i]);      printf("\n");
  57.         initPermutation(str);
  58.         for(i=0;i<8;i++)          printf("%02X  ",str[i]);      printf("\n");
  59.         conversePermutation(str);
  60.         for(i=0;i<8;i++)          printf("%02X  ",str[i]);      printf("\n");
  61.     return 0;
  62. }
复制代码
F6  56  21  33  9E  25  29  D3  
0D  9C  16  78  0E  8F  6F  1D  
F6  56  21  33  9E  25  29  D3  
[Finished in 4.5s]

收藏 评论4 发布时间:2018-8-1 09:17

举报

4个回答
stm1024 回答时间:2018-8-1 09:40:49
本帖最后由 stm1024 于 2018-8-1 10:34 编辑

这个函数简单来说就是把字符串给你打乱了,做简单的加密,既然加密算法你都知道了,直接还原肯定不是难事。
简单的分析认为,这个InData应该是一个8字节的数据,经过处理后,就变成了另外的一个8字节数据了。
通常有两种方法:
一种是暴力枚举,这个加密算法比较友好,原字节和新字节都是一一对应的,所以找到0x00-0xff与之对应的每一个新字符,然后反向查找即可,不过建立这个的前提是,原字节和新字节应该是一一对应的关系,不允许存在类似 0x12和0x33都对应0x78这种问题。
另一种方法就是深入的算法攻击,相当于是求解这个加密函数的逆函数,同样需要存在一一映射关系。先拿第一种方法做测试:
  1. #include <stdio.h>
  2. #include <stdlib.h>

  3. const unsigned char BitCP[64] =
  4. { 36, 7, 40, 60, 43, 19, 47, 23,
  5. 34, 4, 39, 8, 42, 26, 46, 29,
  6. 33, 1, 38, 16, 57, 18, 51, 28,
  7. 32, 0, 37, 12, 56, 10, 45, 21,
  8. 53, 3, 6, 61, 44, 54, 5, 35,
  9. 15, 48, 55, 58, 20, 22, 31, 25,
  10. 9, 41, 13, 14, 59, 30, 2, 63,
  11. 11, 27, 17, 49, 62, 24, 52, 50 };


  12. void conversePermutation(unsigned char* inData)
  13. {
  14.         unsigned char newData[8]={0,0,0,0,0,0,0,0};
  15.         int i;
  16.         for(i=0;i<64;i++)
  17.         {
  18.             if((inData[BitCP[i]>>3]&(1<<(7-(BitCP[i]&7))))!=0)
  19.                 newData[i>>3]=newData[i>>3]|(1<<(7-(i&7)));
  20.         }
  21.         for(i=0;i<8;i++)
  22.         {
  23.             inData[i]=newData[i];
  24.         }
  25. }

  26. int main()
  27. {
  28.     unsigned char text[8];
  29.     int i,j;

  30.     for(i=0;i<32;i++)
  31.     {
  32.         for(j=0;j<8;j++)
  33.             text[j]=8*i+j;
  34.         conversePermutation(text);


  35.         for(j=0;j<8;j++)
  36.             printf("%02x\t%02x\n",8*i+j,text[j]);
  37.     }
  38.     return 0;
  39. }
复制代码

这段代码的目的是计算0x00-0xff之间对应的所有新字符,结果如下:
  1. 00        02
  2. 01        00
  3. 02        00
  4. 03        22
  5. 04        94
  6. 05        86
  7. 06        05
  8. 07        08
  9. 08        92
  10. 09        40
  11. 0a        01
  12. 0b        32
  13. 0c        9c
  14. 0d        8e
  15. 0e        05
  16. 0f        0a
  17. 10        0e
  18. 11        00
  19. 12        02
  20. 13        22
  21. 14        d5
  22. 15        86
  23. 16        0d
  24. 17        c8
  25. 18        9e
  26. 19        40
  27. 1a        03
  28. 1b        32
  29. 1c        dd
  30. 1d        8e
  31. 1e        0d
  32. 1f        ca
  33. 20        02
  34. 21        8c
  35. 22        04
  36. 23        26
  37. 24        94
  38. 25        96
  39. 26        07
  40. 27        09
  41. 28        92
  42. 29        cc
  43. 2a        05
  44. 2b        36
  45. 2c        9c
  46. 2d        9e
  47. 2e        07
  48. 2f        0b
  49. 30        0e
  50. 31        8c
  51. 32        06
  52. 33        26
  53. 34        d5
  54. 35        96
  55. 36        0f
  56. 37        c9
  57. 38        9e
  58. 39        cc
  59. 3a        07
  60. 3b        36
  61. 3c        dd
  62. 3d        9e
  63. 3e        0f
  64. 3f        cb
  65. 40        02
  66. 41        00
  67. 42        c8
  68. 43        22
  69. 44        94
  70. 45        87
  71. 46        c5
  72. 47        38
  73. 48        92
  74. 49        40
  75. 4a        c9
  76. 4b        32
  77. 4c        9c
  78. 4d        8f
  79. 4e        c5
  80. 4f        3a
  81. 50        0e
  82. 51        00
  83. 52        ca
  84. 53        22
  85. 54        d5
  86. 55        87
  87. 56        cd
  88. 57        f8
  89. 58        9e
  90. 59        40
  91. 5a        cb
  92. 5b        32
  93. 5c        dd
  94. 5d        8f
  95. 5e        cd
  96. 5f        fa
  97. 60        02
  98. 61        8c
  99. 62        cc
  100. 63        26
  101. 64        94
  102. 65        97
  103. 66        c7
  104. 67        39
  105. 68        92
  106. 69        cc
  107. 6a        cd
  108. 6b        36
  109. 6c        9c
  110. 6d        9f
  111. 6e        c7
  112. 6f        3b
  113. 70        0e
  114. 71        8c
  115. 72        ce
  116. 73        26
  117. 74        d5
  118. 75        97
  119. 76        cf
  120. 77        f9
  121. 78        9e
  122. 79        cc
  123. 7a        cf
  124. 7b        36
  125. 7c        dd
  126. 7d        9f
  127. 7e        cf
  128. 7f        fb
  129. 80        22
  130. 81        10
  131. 82        10
  132. 83        ea
  133. 84        94
  134. 85        c6
  135. 86        05
  136. 87        0c
  137. 88        b2
  138. 89        50
  139. 8a        11
  140. 8b        fa
  141. 8c        9c
  142. 8d        ce
  143. 8e        05
  144. 8f        0e
  145. 90        2e
  146. 91        10
  147. 92        12
  148. 93        ea
  149. 94        d5
  150. 95        c6
  151. 96        0d
  152. 97        cc
  153. 98        be
  154. 99        50
  155. 9a        13
  156. 9b        fa
  157. 9c        dd
  158. 9d        ce
  159. 9e        0d
  160. 9f        ce
  161. a0        22
  162. a1        9c
  163. a2        14
  164. a3        ee
  165. a4        94
  166. a5        d6
  167. a6        07
  168. a7        0d
  169. a8        b2
  170. a9        dc
  171. aa        15
  172. ab        fe
  173. ac        9c
  174. ad        de
  175. ae        07
  176. af        0f
  177. b0        2e
  178. b1        9c
  179. b2        16
  180. b3        ee
  181. b4        d5
  182. b5        d6
  183. b6        0f
  184. b7        cd
  185. b8        be
  186. b9        dc
  187. ba        17
  188. bb        fe
  189. bc        dd
  190. bd        de
  191. be        0f
  192. bf        cf
  193. c0        22
  194. c1        10
  195. c2        d8
  196. c3        ea
  197. c4        94
  198. c5        c7
  199. c6        c5
  200. c7        3c
  201. c8        b2
  202. c9        50
  203. ca        d9
  204. cb        fa
  205. cc        9c
  206. cd        cf
  207. ce        c5
  208. cf        3e
  209. d0        2e
  210. d1        10
  211. d2        da
  212. d3        ea
  213. d4        d5
  214. d5        c7
  215. d6        cd
  216. d7        fc
  217. d8        be
  218. d9        50
  219. da        db
  220. db        fa
  221. dc        dd
  222. dd        cf
  223. de        cd
  224. df        fe
  225. e0        22
  226. e1        9c
  227. e2        dc
  228. e3        ee
  229. e4        94
  230. e5        d7
  231. e6        c7
  232. e7        3d
  233. e8        b2
  234. e9        dc
  235. ea        dd
  236. eb        fe
  237. ec        9c
  238. ed        df
  239. ee        c7
  240. ef        3f
  241. f0        2e
  242. f1        9c
  243. f2        de
  244. f3        ee
  245. f4        d5
  246. f5        d7
  247. f6        cf
  248. f7        fd
  249. f8        be
  250. f9        dc
  251. fa        df
  252. fb        fe
  253. fc        dd
  254. fd        df
  255. fe        cf
  256. ff        ff
复制代码
不知道这么分析是否正确




评分

参与人数 1蝴蝶豆 +4 收起 理由
zero99 + 4

查看全部评分

与龙共舞 回答时间:2018-8-1 11:20:14
本帖最后由 与龙共舞 于 2018-8-1 11:21 编辑
stm1024 发表于 2018-8-1 09:40
这个函数简单来说就是把字符串给你打乱了,做简单的加密,既然加密算法你都知道了,直接还原肯定不是难事。 ...

这个循环挺高级的 0--0xff的双循环
所以现在是成功做了一个对应关系表吗 0--0xff和右边对应起来 但是多对一的情况出现了
butterflyspring 回答时间:2018-8-1 11:42:12
desData这个是啥?DES加密?

评分

参与人数 1蝴蝶豆 +2 收起 理由
zero99 + 2

查看全部评分

feixiang20 回答时间:2018-8-2 02:00:58
类似的可以使用Python解密小技巧么

所属标签

相似问题

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32Cube扩展软件包
意法半导体边缘AI套件
ST - 理想汽车豪华SUV案例
ST意法半导体智能家居案例
STM32 ARM Cortex 32位微控制器
关注我们
st-img 微信公众号
st-img 手机版