21ic电子技术开发论坛 › 综合技术交流 › RISC-V › 沁恒 CH32V103实现des加密解密base64加密解密 ...
12下一页
返回列表 发新帖我要提问

[RISC-V MCU 创新应用比赛] 沁恒 CH32V103实现des加密解密base64加密解密

[复制链接]
 楼主| liupk 发表于 2021-9-24 17:01 | 显示全部楼层 |阅读模式
本帖最后由 liupk 于 2021-9-28 20:24 编辑

#申请原创# 本设计基于 CH32V103开发板
0.jpg

CH32V103开发板相关资料如下
CH32xRM.PDF (2.93 MB, 下载次数: 0)
CH32V103评估板说明书.pdf (1.08 MB, 下载次数: 0)
CH32V103SCH.pdf (579.11 KB, 下载次数: 0)
CH32V103DS0.PDF (2 MB, 下载次数: 0)

硬件部分只需要一根usb线连接P9 TYPE-C接口   
该接口既可以下载程序又可以当做串口1使用

为了测试方便，写了个上位机
1.png


由上位机发送数据，CH32V103开发板通过串口1接收数据。开发板根据上位机的命令要求返回对应类型的加密数据或者解密数据。

主要实现的功能有  
1.des加密+hex格式显示
2.des加密+base64格式显示
3.des解密+hex格式显示
4.des解密+base64格式显示
5.base64加密
6.base64解密
例如当上位机选择了    5.base64加密    然后在上位机输入框中输入12345678点击发送按钮，则开发板会通过串口1返回给上位机  MTIzNDU2Nzg=








回复 赏

举报

 楼主| liupk 发表于 2021-9-24 17:05 | 显示全部楼层
本帖最后由 liupk 于 2021-9-29 19:25 编辑

资料上传到了阿里云盘   https://pages.aliyundrive.com/mobile-page/web/beinvited.html?code=2a7cda6

CH32V103程序   https://www.aliyundrive.com/s/SdJrdHrxzRy

上位机工程  https://www.aliyundrive.com/s/Y2oSFzTiEzn

上位机exe文件可直接运行  https://www.aliyundrive.com/s/u1zrZ8DqfFa






回复 赏

举报

cooldog123pp 发表于 2021-9-25 17:06 | 显示全部楼层
厉害了我的哥，现在国产芯也是越做越好，希望国产芯片越来越好用~~
回复 赏

举报

 楼主| liupk 发表于 2021-9-26 13:54 | 显示全部楼层
本帖最后由 liupk 于 2021-9-28 20:32 编辑

上位机打开演示
第一种方法：下载上位机工程代码

4216361541555d4512.png

打开Serialport文件夹

13789615415756a708.png

打开sketch_210212a文件夹

24769615415863e741.png

打开application.windows64文件夹

919416154159817270.png

双击sketch_210212a.exe即可打开上位机
36869615415a971e94.png

40703615415bd79ead.png
第二种方法：下载上位机exe文件可直接运行


767736154161165834.png

打开application.windows64文件夹

2107861541668c5e52.png

双击sketch_210212a.exe即可打开上位机
4721615416962b831.png

1269361541681b27b1.png

回复 赏

举报

 楼主| liupk 发表于 2021-9-26 14:18 | 显示全部楼层
本帖最后由 liupk 于 2021-9-29 16:06 编辑

测试1.des加密+hex格式显示 9842761500f9e77eb9.png
第一步选择1.des加密+hex格式显示
第二步输入8位des秘钥
第三步根据设备管理器来选择com口例如我的是com3
第四步选择串口波特率为115200，因为开发板上暂时设置的是115200
第五步选择hex显示
第六步点击连接
第七步点击发送
实现的功能是  des加密  hex显示  
明文是    http://www.wch.cn/     秘钥是12345678
结果是    e9fdd32ccd50885c7efcea7a170ba6b2e7753d3ef167950a
通过和http://tool.chacuo.net/cryptdes网站在线测试对比结果一致
23087615011aa6d595.png



回复 赏

举报

 楼主| liupk 发表于 2021-9-26 15:48 | 显示全部楼层
本帖最后由 liupk 于 2021-9-29 16:12 编辑

测试2.des加密+base64格式显示


58590615024ff2c4ba.png

第一步选择2.des加密+base64格式显示
第二步输入8位des秘钥
第三步根据设备管理器来选择com口例如我的是com3
第四步选择串口波特率为115200，因为开发板上暂时设置的是115200

第六步点击连接
第七步点击发送
实现的功能是  des加密  base64显示  
明文是    http://www.wch.cn/     秘钥是12345678
结果是    6f3TLM1QiFx+/Op6Fwumsud1PT7xZ5UK
通过和http://tool.chacuo.net/cryptdes网站在线测试对比结果一致 82945615025d321b3d.png


回复 赏

举报

 楼主| liupk 发表于 2021-9-30 09:25 | 显示全部楼层
本帖最后由 liupk 于 2021-9-29 16:14 编辑

测试3.des解密+hex格式显示

686206155118eb8976.png


第一步选择3.des解密+hex格式显示
第二步输入8位des秘钥
第三步根据设备管理器来选择com口例如我的是com3
第四步选择串口波特率为115200，因为开发板上暂时设置的是115200
第六步点击连接
第七步点击发送
实现的功能是  des解密  hex显示  
明文是    e9fdd32ccd50885c7efcea7a170ba6b2e7753d3ef167950a     秘钥是12345678
结果是    http://www.wch.cn/

通过和http://tool.chacuo.net/cryptdes网站在线测试对比结果一致


94314615511dba3375.png









回复 赏

举报

 楼主| liupk 发表于 2021-9-30 09:53 | 显示全部楼层
本帖最后由 liupk 于 2021-9-29 16:15 编辑

测试4.des解密+base64格式显示


36035615518311e5b8.png


第一步选择4.des解密+base64格式显示
第二步输入8位des秘钥
第三步根据设备管理器来选择com口例如我的是com3
第四步选择串口波特率为115200，因为开发板上暂时设置的是115200
第六步点击连接
第七步点击发送
实现的功能是  des解密  hex显示  
明文是    6f3TLM1QiFx+/Op6Fwumsud1PT7xZ5UK     秘钥是12345678
结果是    http://www.wch.cn/

通过和http://tool.chacuo.net/cryptdes网站在线测试对比结果一致


60121615518a55adb2.png



回复 赏

举报

 楼主| liupk 发表于 2021-9-30 10:30 | 显示全部楼层
本帖最后由 liupk 于 2021-9-29 16:18 编辑

测试5.base64加密

8964261552c54c7738.png

第一步选择5.base64加密
第三步根据设备管理器来选择com口例如我的是com3
第四步选择串口波特率为115200，因为开发板上暂时设置的是115200
第六步点击连接
第七步点击发送
实现的功能是  des解密  hex显示  
明文是    http://www.wch.cn/
结果是    aHR0cDovL3d3dy53Y2guY24v
95890615521b07d4ab.png

通过和http://tools.jb51.net/tools/base64_decode-utf8.php网站在线测试对比结果一致

回复 赏

举报

 楼主| liupk 发表于 2021-9-30 11:03 | 显示全部楼层
测试6.base64解密


485436155271776bbe.png


第一步选择6.base64解密
第三步根据设备管理器来选择com口例如我的是com3
第四步选择串口波特率为115200，因为开发板上暂时设置的是115200
第六步点击连接
第七步点击发送
实现的功能是  base64解密
明文是    aHR0cDovL3d3dy53Y2guY24v   
结果是    http://www.wch.cn/

56675615528f2cc553.png

通过和http://tools.jb51.net/tools/base64_decode-utf8.php网站在线测试对比结果一致




回复 赏

举报

 楼主| liupk 发表于 2021-9-30 13:46 | 显示全部楼层
测试7.普通串口上位机
当做普通串口上位机使用即可，不再做演示。
回复 赏

举报

 楼主| liupk 发表于 2021-9-30 13:52 | 显示全部楼层
首次使用 3895861554fa6f360c.png MounRiver Studio，整体感觉还是比较纵享丝滑的。
界面也很简洁非常容易上手，并且也提供了大量的外设例程供参考
63525615550a780217.png
回复 赏

举报

 楼主| liupk 发表于 2021-9-30 13:55 | 显示全部楼层
des的代码如下
复制
  1. /*-------------------------------------------------------
    

  2.    DES 加密   8字节为一个数据块
    

  3.    实现单、双、三DES加密解密 并实现CBC模式接口
    

  4. --------------------------------------------------------*/
    

  5. #include "des.h"
    


  6. 

  7. // 对明文执行IP置换得到L0,R0 （L左32位,R右32位）               [明文操作]
    

  8. const unsigned char IP_Table[64] = {
    

  9.     58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
    

  10.     62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
    

  11.     57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
    

  12.     61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
    

  13. };
    


  14. 

  15. // 对迭代后的L16,R16执行IP逆置换,输出密文
    

  16. const unsigned char IPR_Table[64] = {
    

  17.     40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
    

  18.     38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
    

  19.     36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
    

  20.     34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25
    

  21. };
    


  22. 

  23. /*--------------------------- 迭代法则 ----------------------------*/
    


  24. 

  25. // F函数,32位的R0进行E变换,扩为48位输出 (R1~R16)        [备用A]  [明文操作]
    

  26. const unsigned char E_Table[48] = {
    

  27.     32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,
    

  28.     8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
    

  29.     16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
    

  30.     24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1
    

  31. };
    


  32. 

  33. // 子密钥K(i)的获取 密钥为K 抛弃第6,16,24,32,40,48,64位          [密钥操作]
    

  34. // 用PC1选位 分为 前28位C0,后28位D0 两部分
    

  35. const unsigned char PC1_Table[56] = {
    

  36.     57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
    

  37.     10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
    

  38.     63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
    

  39.     14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
    

  40. };
    


  41. 

  42. // 对C0,D0分别进行左移,共16次,左移位数与下面对应                 [密钥操作]
    

  43. const unsigned char Move_Table[16] = {
    

  44.     1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
    

  45. };
    


  46. 

  47. // C1,D1为第一次左移后得到,进行PC2选位,得到48位输出K1   [备用B]   [密钥操作]
    

  48. const unsigned char PC2_Table[48] = {
    

  49.     14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
    

  50.     23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
    

  51.     41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
    

  52.     44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
    

  53. };
    


  54. 

  55. /*------------- F函数 备用A和备用B 异或 得到48位输出 ---------------*/
    


  56. 

  57. // 异或后的结果48位分为8组,每组6位,作为8个S盒的输入             [组合操作]
    

  58. // S盒以6位作为输入(8组),4位作为输出(4*(8组)=32位)
    

  59. // S工作原理 假设输入为A=abcdef ,则bcde所代表的数是0-15之间的
    

  60. // 一个数记为 X=bcde ,af代表的是0-3之间的一个数,记为 Y=af
    

  61. // 在S1的X列,Y行找到一个数Value,它在0-15之间,可以用二进制表示
    

  62. // 所以为4bit (共32位)
    

  63. const unsigned char S_Box[8][4][16] = {
    

  64.     // S1
    

  65.     14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
    

  66.     0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
    

  67.     4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
    

  68.     15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
    

  69.     // S2
    

  70.     15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
    

  71.     3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
    

  72.     0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
    

  73.     13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
    

  74.     // S3
    

  75.     10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
    

  76.     13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
    

  77.     13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
    

  78.     1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
    

  79.     // S4
    

  80.     7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
    

  81.     13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
    

  82.     10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
    

  83.     3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
    

  84.     // S5
    

  85.     2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
    

  86.     14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
    

  87.     4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
    

  88.     11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
    

  89.     // S6
    

  90.     12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
    

  91.     10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
    

  92.     9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
    

  93.     4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
    

  94.     // S7
    

  95.     4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
    

  96.     13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
    

  97.     1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
    

  98.     6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
    

  99.     // S8
    

  100.     13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
    

  101.     1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
    

  102.     7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
    

  103.     2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
    

  104. };
    


  105. 

  106. // F函数 最后第二步,对S盒输出的32进行P置换                     [组合操作]
    

  107. // 输出的值参与一次迭代:
    

  108. // L(i)=R(i-1)
    

  109. // R(i)=L(i-1)^f(R(i-1),K(i)) 异或
    

  110. const unsigned char P_Table[32] = {
    

  111.     16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
    

  112.     2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
    

  113. };
    


  114. 

  115. // 16个子密钥K(1~16)
    

  116. static unsigned char SubKey[16][48] = { 0 };
    


  117. 


  118. 

  119. /*-------------------------------
    

  120. 把DatIn开始的长度位Len位的二进制
    

  121. 复制到DatOut后
    

  122. --------------------------------*/
    

  123. void BitsCopy(unsigned char *DatOut, unsigned char *DatIn, int Len)     // 数组复制 OK
    

  124. {
    

  125.     int i = 0;
    

  126.     for (i = 0; i < Len; i++)
    

  127.     {
    

  128.         DatOut[i] = DatIn[i];
    

  129.     }
    

  130. }
    


  131. 

  132. /*-------------------------------
    

  133. 字节转换成位函数
    

  134. byte_Num 多少个字节
    

  135. --------------------------------*/
    

  136. void ByteToBit(unsigned char *DatOut, unsigned char *DatIn, int byte_Num)       // OK
    

  137. {
    

  138.     int i = 0;
    

  139.     for (i = 0; i < byte_Num * 8; i++)
    

  140.     {
    

  141.         //低bit在缓存高地址
    

  142.         DatOut[i] = ((DatIn[i / 8] << (i % 8)) & 0x80) ? 1 : 0;
    

  143.     }
    

  144. }
    


  145. 

  146. /*-------------------------------
    

  147. 位转换成字节函数
    

  148. byte_Num: 多少个字节
    

  149. ---------------------------------*/
    

  150. void BitToByte(unsigned char *DatOut, unsigned char *DatIn, int byte_Num)        // OK
    

  151. {
    

  152.     int i = 0;
    

  153.     for (i = 0; i < byte_Num; i++)  //先把数据清零
    

  154.     {
    

  155.         DatOut[i] = 0;
    

  156.     }
    

  157.     for (i = 0; i < byte_Num * 8; i++)
    

  158.     {
    

  159.         DatOut[i / 8] = (DatOut[i / 8] << 1) | DatIn[i];  //低bit在缓存高地址
    

  160.     }
    

  161. }
    


  162. 

  163. // 表置换函数  OK
    

  164. void TablePermute(unsigned char *DatOut, unsigned char *DatIn, const unsigned char *Table, int Num)
    

  165. {
    

  166.     int i = 0;
    

  167.     unsigned char Temp[256] = { 0 };
    

  168.     for (i = 0; i < Num; i++)                // Num为置换的长度
    

  169.     {
    

  170.         Temp[i] = DatIn[Table[i] - 1];  // 原来的数据按对应的表上的位置排列
    

  171.     }
    

  172.     BitsCopy(DatOut, Temp, Num);       // 把缓存Temp的值输出
    

  173. }
    


  174. 

  175. // 子密钥的移位
    

  176. void LoopMove(unsigned char *DatIn, int Len, int Num) // 循环左移 Len数据长度 Num移动位数
    

  177. {
    

  178.     unsigned char Temp[10] = { 0 };    // 缓存
    

  179.     BitsCopy(Temp, DatIn, Num);       // 将数据最左边的Num位(被移出去的)存入Temp
    

  180.     BitsCopy(DatIn, DatIn + Num, Len - Num); // 将数据左边开始的第Num移入原来的空间
    

  181.     BitsCopy(DatIn + Len - Num, Temp, Num);  // 将缓存中移出去的数据加到最右边
    

  182. }
    


  183. 

  184. // 按位异或
    

  185. void Xor(unsigned char *DatA, unsigned char *DatB, int Num)           // 异或函数
    

  186. {
    

  187.     int i = 0;
    

  188.     for (i = 0; i < Num; i++)
    

  189.     {
    

  190.         DatA[i] = DatA[i] ^ DatB[i];                  // 异或
    

  191.     }
    

  192. }
    


  193. 

  194. // 输入48位 输出32位 与Ri异或。
    

  195. //把48bit 数据分成八组 进入八个S盒 得到8个十进制数，把8个十进制数转换成32位bit串
    

  196. void S_Change(unsigned char *DatOut, unsigned char *DatIn)    // S盒变换
    

  197. {
    

  198.     int i, X, Y;                                    // i为8个S盒
    

  199.     unsigned char data[8];                       //S盒中的数据
    

  200.     for (i = 0, Y = 0, X = 0; i < 8; i++, DatIn += 6)         // 每执行一次,输入数据偏移6位
    

  201.     {                                             // 每执行一次,输出数据偏移4位
    

  202.         Y = (DatIn[0] << 1) + DatIn[5];                          // af代表第几行
    

  203.         X = (DatIn[1] << 3) + (DatIn[2] << 2) + (DatIn[3] << 1) + DatIn[4]; // bcde代表第几列
    

  204.         data[i] = S_Box[i][Y][X];  //得到S盒中的数据  4bit 数据
    

  205.     }
    

  206.     // 把找到的点数据换为二进制
    

  207.     for (i = 0; i < 8; i++)
    

  208.     {
    

  209.         DatOut[i * 4 + 0] = (data[i] & 0x08) ? 1 : 0; //最高位
    

  210.         DatOut[i * 4 + 1] = (data[i] & 0x04) ? 1 : 0;
    

  211.         DatOut[i * 4 + 2] = (data[i] & 0x02) ? 1 : 0;
    

  212.         DatOut[i * 4 + 3] = (data[i] & 0x01) ? 1 : 0;
    

  213.     }
    

  214. }
    


  215. 

  216. // F函数
    

  217. void F_Change(unsigned char *DatIn, unsigned char *DatKi)       // F函数
    

  218. {
    

  219.     unsigned char MiR[48] = { 0 };             // 输入32位通过E选位变为48位
    

  220.     TablePermute(MiR, DatIn, E_Table, 48);      //把32bit 数据扩展到 48bit
    

  221.     Xor(MiR, DatKi, 48);                   // 和子密钥异或
    

  222.     S_Change(DatIn, MiR);                 // S盒变换 把48bit 数据分成八组 进入八个S盒
    

  223.     TablePermute(DatIn, DatIn, P_Table, 32);   // P置换后输出  32bit串
    

  224. }
    


  225. 


  226. 

  227. //设置默认密钥 获取子密钥Ki
    

  228. void Set_One_DES_64bitKey(unsigned char *KeyIn)
    

  229. {
    

  230.     int i = 0;
    

  231.     unsigned char KeyBit[64] = { 0 };                // 密钥二进制存储空间
    

  232.     unsigned char *KiL = &KeyBit[0];    //前28
    

  233.     unsigned char *KiR = &KeyBit[28];  //后28共56
    

  234.     ByteToBit(KeyBit, KeyIn, 8);                    // 把密钥转为二进制存入KeyBit
    

  235.     TablePermute(KeyBit, KeyBit, PC1_Table, 56);      // PC1表置换 56次
    

  236.     for (i = 0; i < 16; i++)
    

  237.     {
    

  238.         LoopMove(KiL, 28, Move_Table[i]);       // 前28位左移
    

  239.         LoopMove(KiR, 28, Move_Table[i]);         // 后28位左移
    

  240.         TablePermute(SubKey[i], KeyBit, PC2_Table, 48);  //得到48位 子秘钥
    

  241.         // 二维数组 SubKey[i]为每一行起始地址
    

  242.         // 每移一次位进行PC2置换得 Ki 48位
    

  243.     }
    

  244. }
    


  245. 

  246. // 执行DES加密
    

  247. void DES_Encrypt_Block(unsigned char *MesIn, unsigned char *MesOut)
    

  248. {                                           // 字节输入 Bin运算 Hex输出
    

  249.     int i = 0;
    

  250.     unsigned char MesBit[64] = { 0 };        // 明文二进制存储空间 64位
    

  251.     unsigned char Temp[32] = { 0 };
    

  252.     unsigned char *MiL = &MesBit[0];//前32位
    

  253.     unsigned char *MiR = &MesBit[32]; //  后32位
    

  254.     ByteToBit(MesBit, MesIn, 8);                 // 把明文换成二进制存入MesBit
    

  255.     TablePermute(MesBit, MesBit, IP_Table, 64);    // IP置换
    


  256. 

  257.     for (i = 0; i < 16; i++)                       // 迭代16次
    

  258.     {
    

  259.         BitsCopy(Temp, MiL, 32);             // 临时存储 备份 Li-1
    

  260.         BitsCopy(MiL, MiR, 32);              // 得到Li   Li = Ri-1
    

  261.         F_Change(MiR, SubKey[i]);           // F函数变换  进行E扩展 变成48位 与子秘钥异或
    

  262.         Xor(MiR, Temp, 32);                  // 得到Ri   Ri =Li-1 异或 F（Ri-1，Ki）
    

  263.     }
    

  264.     //最后一轮要改变左右32bit位置   Ri在前 Li 在后进行合并   合并后进行IP逆置换
    

  265.     BitsCopy(Temp, MiL, 32);   //把左边 32bit 备份
    

  266.     BitsCopy(MesBit, MiR, 32);  //把右32位 移到前面
    

  267.     BitsCopy(&MesBit[32], Temp, 32);  //把前32位 移到后面  合并完成
    

  268.     TablePermute(MesBit, MesBit, IPR_Table, 64); //进行IP逆置换
    

  269.     BitToByte(MesOut, MesBit, 8);
    

  270. }
    


  271. 

  272. // 执行DES解密
    

  273. void DES_Decode_Block(unsigned  char *MesIn, unsigned char *MesOut)
    

  274. {                                             // Hex输入 Bin运算 字节输出
    

  275.     int i = 0;
    

  276.     unsigned char MesBit[64] = { 0 };         // 密文二进制存储空间 64位
    

  277.     unsigned char Temp[32] = { 0 };
    

  278.     unsigned char *MiL = &MesBit[0];  //前32位
    

  279.     unsigned char *MiR = &MesBit[32]; //  后32位
    

  280.     ByteToBit(MesBit, MesIn, 8);
    

  281.     TablePermute(MesBit, MesBit, IP_Table, 64);    // IP置换
    


  282. 

  283.     for (i = 0; i < 16; i++)
    

  284.     {
    

  285.         BitsCopy(Temp, MiL, 32);             // 临时存储 备份 Li-1
    

  286.         BitsCopy(MiL, MiR, 32);              // 得到Li   Li = Ri-1
    

  287.         F_Change(MiR, SubKey[15 - i]);        // F函数变换  进行E扩展 变成48位 与子秘钥异或
    

  288.         Xor(MiR, Temp, 32);                   // 得到Ri   Ri =Li-1 异或 F（Ri-1，Ki）
    

  289.     }
    

  290.     //最后一轮需要左右对换 Ri在前 Li 在后进行合并   合并后进行IP逆置换
    

  291.     BitsCopy(Temp, MiL, 32);   //把左边 32bit 备份
    

  292.     BitsCopy(MesBit, MiR, 32);  //把右32位 移到前面
    

  293.     BitsCopy(&MesBit[32], Temp, 32);  //把前32位 移到后面  合并完成
    

  294.     TablePermute(MesBit, MesBit, IPR_Table, 64);
    

  295.     BitToByte(MesOut, MesBit, 8);
    

  296. }
    


  297. 

  298. /*************************************************************************************
    

  299. 以下函数加入 DES算法 向量    为CBC加密模式 提供接口
    

  300. 一、加密过程 ：
    

  301. 密文块0 = （明文0 异或 IV ）的结果   用秘钥加密
    

  302. 密文块1 = （明文1 异或 密文块0） 的结果 用秘钥加密
    

  303. 二、解密过程 ：
    

  304. 1、先用秘钥对密文解密  得到 数据  X0
    

  305. 2、X0 异或 向量  得到明文
    

  306. 3、前一个数据的密文块 为后一个数据块的向量
    

  307. ***************************************************************************************/
    


  308. 

  309. //执行单DES加密  加密一个块      8字节数据
    

  310. //IV_IN_OUT：    初始化向量输入  密文输出  为空时则无向量值（CBC模式加密时，前一个数据的密文为后一个明文块的向量）
    

  311. //Mes_IN_OUT:    明文输入        密文输出
    

  312. //Key64bit:      64bit 秘钥      8字节
    

  313. void One_DES_IV_Encrypt_Block(unsigned char *IV_IN_OUT, unsigned char *Mes_IN, unsigned char *Mes_OUT,unsigned char *Key64bit)
    

  314. {
    

  315.     unsigned char   temp[8];
    

  316.     if (Key64bit == NULL)  //秘钥不能为空
    

  317.     {
    

  318.         return;
    

  319.     }
    

  320.     if (IV_IN_OUT != NULL)
    

  321.     {
    

  322.         Xor(Mes_IN, IV_IN_OUT, 8);     //先把明文数据与加密向量 异或   如果向量全为0 则不改变明文的值
    

  323.     }
    

  324.     Set_One_DES_64bitKey(Key64bit);        //设置秘钥  生成子秘钥
    

  325.     DES_Encrypt_Block(Mes_IN, temp);   //执行DES加密  密文保存在 temp 中
    

  326.     if (IV_IN_OUT != NULL)
    

  327.     {
    

  328.         BitsCopy(IV_IN_OUT, temp, 8);      //把密文拷贝到向量缓存中
    

  329.     }
    

  330.     BitsCopy(Mes_OUT, temp, 8);         //把密文拷贝到明文数据缓存中
    

  331. }
    


  332. 


  333. 

  334. //执行单DES解密  解密一个块      8字节数据
    

  335. //IV_IN_OUT：    初始化向量输入  原密文输出 为空时则无向量值（CBC模式解密时，前一个数据块的密文为后一个密文块解密后的向量）
    

  336. //Mes_IN_OUT:    密文输入        明文输出
    

  337. //Key64bit:      64bit 秘钥      8字节
    

  338. void One_DES_IV_Decode_Block(unsigned char *IV_IN_OUT, unsigned char *Mes_IN, unsigned char *Mes_OUT, unsigned char *Key64bit)
    

  339. {
    

  340.     unsigned char   temp[8];
    

  341.     if (Key64bit == NULL)  //秘钥不能为空
    

  342.     {
    

  343.         return;
    

  344.     }
    

  345.     Set_One_DES_64bitKey(Key64bit);            //设置秘钥  生成子秘钥
    

  346.     DES_Decode_Block(Mes_IN, temp);        //执行DES解密  解密的结果保存在 temp 中
    

  347.     if (IV_IN_OUT != NULL)
    

  348.     {
    

  349.         Xor(temp, IV_IN_OUT, 8);               //把解密后的结果与向量异或得到明文  如果向量全为0 则不改变值
    

  350.         BitsCopy(IV_IN_OUT, Mes_IN, 8);    //把原密文拷贝到向量数据缓存中
    

  351.     }
    

  352.     BitsCopy(Mes_OUT, temp, 8);             //把明文拷贝到密文数据缓存中
    

  353. }
    


  354. 


  355. 


  356. 


  357. 

  358. //执行双DES加密  加密一个块      8字节数据 加密顺序  左加密 右解密 左加密
    

  359. //IV_IN_OUT：    初始化向量输入  密文输出 （CBC模式加密时，前一个数据的密文为后一个明文块的向量）
    

  360. //Mes_IN_OUT:    明文输入        密文输出
    

  361. //Key128bit:     128bit 秘钥     16字节
    

  362. void Two_DES_IV_Encrypt_Block(unsigned char *IV_IN_OUT, unsigned char *Mes_IN_OUT, unsigned char *Key128bit)
    

  363. {
    

  364.     unsigned char   temp[8];
    

  365.     if (Key128bit == NULL)
    

  366.     {
    

  367.         return;
    

  368.     }
    

  369.     if (IV_IN_OUT != NULL)
    

  370.     {
    

  371.         Xor(Mes_IN_OUT, IV_IN_OUT, 8);          //先把明文数据与加密向量 异或   如果向量全为0 则不改变明文的值
    

  372.     }
    


  373. 

  374.     Set_One_DES_64bitKey(Key128bit);            //设置秘钥  生成子秘钥    左边8字节秘钥
    

  375.     DES_Encrypt_Block(Mes_IN_OUT, temp);        //执行DES加密  密文保存在 temp 中
    


  376. 

  377.     Set_One_DES_64bitKey(&Key128bit[8]);        //设置秘钥  生成子秘钥    右边8字节秘钥
    

  378.     DES_Decode_Block(temp, temp);               //执行DES解密  结果保存在 temp 中
    


  379. 

  380.     Set_One_DES_64bitKey(Key128bit);            //设置秘钥  生成子秘钥    左边8字节秘钥
    

  381.     DES_Encrypt_Block(temp, temp);              //执行DES加密  密文保存在 temp 中
    


  382. 

  383.     if (IV_IN_OUT != NULL)
    

  384.     {
    

  385.         BitsCopy(IV_IN_OUT, temp, 8);           //把密文拷贝到向量缓存中
    

  386.     }
    

  387.     BitsCopy(Mes_IN_OUT, temp, 8);              //把密文拷贝到明文数据缓存中
    

  388. }
    


  389. 


  390. 

  391. //执行双DES解密  解密一个块      8字节数据 解密流程  左解密  右加密   左解密
    

  392. //IV_IN_OUT：    初始化向量输入  原密文输出 为空时则无向量值（CBC模式解密时，前一个数据块的密文为后一个密文块解密后的向量）
    

  393. //Mes_IN_OUT:    密文输入        明文输出
    

  394. //Key128bit:     128bit 秘钥     16字节
    

  395. void Two_DES_IV_Decode_Block(unsigned char *IV_IN_OUT, unsigned char *Mes_IN_OUT, unsigned char *Key128bit)
    

  396. {
    

  397.     unsigned char   temp[8];
    

  398.     if (Key128bit == NULL)  //秘钥不能为空
    

  399.     {
    

  400.         return;
    

  401.     }
    

  402.     Set_One_DES_64bitKey(Key128bit);           //设置秘钥  生成子秘钥
    

  403.     DES_Decode_Block(Mes_IN_OUT, temp);        //执行DES解密  解密的结果保存在 temp 中
    


  404. 


  405. 

  406.     Set_One_DES_64bitKey(&Key128bit[8]);       //设置秘钥  生成子秘钥    右边8字节秘钥
    

  407.     DES_Encrypt_Block(temp, temp);             //执行DES加密  密文保存在 temp 中
    


  408. 

  409.     Set_One_DES_64bitKey(Key128bit);           //设置秘钥  生成子秘钥
    

  410.     DES_Decode_Block(temp, temp);              //执行DES解密  解密的结果保存在 temp 中
    


  411. 

  412.     if (IV_IN_OUT != NULL)
    

  413.     {
    

  414.         Xor(temp, IV_IN_OUT, 8);               //把解密后的结果与向量异或得到明文  如果向量全为0 则不改变值
    

  415.         BitsCopy(IV_IN_OUT, Mes_IN_OUT, 8);    //把原密文拷贝到向量数据缓存中
    

  416.     }
    

  417.     BitsCopy(Mes_IN_OUT, temp, 8);             //把明文拷贝到密文数据缓存中
    

  418. }
    


  419. 


  420. 


  421. 

  422. //执行三DES加密  加密一个块      8字节数据 加密顺序  左加密 中解密 右加密
    

  423. //IV_IN_OUT：    初始化向量输入  密文输出 （CBC模式加密时，前一个数据的密文为后一个明文块的向量）
    

  424. //Mes_IN_OUT:    明文输入        密文输出
    

  425. //Key192bit:     192bit 秘钥     24字节
    

  426. void Three_DES_IV_Encrypt_Block(unsigned char *IV_IN_OUT, unsigned char *Mes_IN_OUT, unsigned char *Key192bit)
    

  427. {
    

  428.     unsigned char   temp[8];
    

  429.     if (Key192bit == NULL)
    

  430.     {
    

  431.         return;
    

  432.     }
    

  433.     if (IV_IN_OUT != NULL)
    

  434.     {
    

  435.         Xor(Mes_IN_OUT, IV_IN_OUT, 8);          //先把明文数据与加密向量 异或   如果向量全为0 则不改变明文的值
    

  436.     }
    


  437. 

  438.     Set_One_DES_64bitKey(Key192bit);            //设置秘钥  生成子秘钥    左边8字节秘钥
    

  439.     DES_Encrypt_Block(Mes_IN_OUT, temp);        //执行DES加密  密文保存在 temp 中
    


  440. 

  441.     Set_One_DES_64bitKey(&Key192bit[8]);        //设置秘钥  生成子秘钥    中间8字节秘钥
    

  442.     DES_Decode_Block(temp, temp);               //执行DES解密  结果保存在 temp 中
    


  443. 

  444.     Set_One_DES_64bitKey(&Key192bit[16]);       //设置秘钥  生成子秘钥    右边8字节秘钥
    

  445.     DES_Encrypt_Block(temp, temp);              //执行DES加密  密文保存在 temp 中
    


  446. 

  447.     if (IV_IN_OUT != NULL)
    

  448.     {
    

  449.         BitsCopy(IV_IN_OUT, temp, 8);           //把密文拷贝到向量缓存中
    

  450.     }
    

  451.     BitsCopy(Mes_IN_OUT, temp, 8);              //把密文拷贝到明文数据缓存中
    

  452. }
    


  453. 


  454. 


  455. 


  456. 

  457. //执行三DES解密  解密一个块      8字节数据 解密流程  右解密  中加密   左解密
    

  458. //IV_IN_OUT：    初始化向量输入  原密文输出 为空时则无向量值（CBC模式解密时，前一个数据块的密文为后一个密文块解密后的向量）
    

  459. //Mes_IN_OUT:    密文输入        明文输出
    

  460. //Key192bit:     192bit 秘钥     24字节
    

  461. void Three_DES_IV_Decode_Block(unsigned char *IV_IN_OUT, unsigned char *Mes_IN_OUT, unsigned char *Key192bit)
    

  462. {
    

  463.     unsigned char   temp[8];
    

  464.     if (Key192bit == NULL)  //秘钥不能为空
    

  465.     {
    

  466.         return;
    

  467.     }
    

  468.     Set_One_DES_64bitKey(&Key192bit[16]);      //设置秘钥  生成子秘钥  右边8字节秘钥
    

  469.     DES_Decode_Block(Mes_IN_OUT, temp);        //执行DES解密  解密的结果保存在 temp 中
    


  470. 


  471. 

  472.     Set_One_DES_64bitKey(&Key192bit[8]);       //设置秘钥  生成子秘钥    中间8字节秘钥
    

  473.     DES_Encrypt_Block(temp, temp);             //执行DES加密  密文保存在 temp 中
    


  474. 

  475.     Set_One_DES_64bitKey(Key192bit);           //设置秘钥  生成子秘钥  左边8字节秘钥
    

  476.     DES_Decode_Block(temp, temp);              //执行DES解密  解密的结果保存在 temp 中
    


  477. 

  478.     if (IV_IN_OUT != NULL)
    

  479.     {
    

  480.         Xor(temp, IV_IN_OUT, 8);               //把解密后的结果与向量异或得到明文  如果向量全为0 则不改变值
    

  481.         BitsCopy(IV_IN_OUT, Mes_IN_OUT, 8);    //把原密文拷贝到向量数据缓存中
    

  482.     }
    

  483.     BitsCopy(Mes_IN_OUT, temp, 8);             //把明文拷贝到密文数据缓存中
    

  484. }
    


  485. 


  486. 


  487. 


  488. 


  489. 


  490.


回复 赏

举报

 楼主| liupk 发表于 2021-9-30 13:56 | 显示全部楼层
base64的代码如下

复制
  1. #include<stdio.h>
    

  2. #include<stdlib.h>
    

  3. #include<math.h>
    

  4. #include<string.h>
    

  5. #include"BASE64.h"
    


  6. 

  7. static const char base64char[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    


  8. 

  9. /* 在字符串中查询特定字符的索引 */
    

  10. int charIndex(const char* str, char c)
    

  11. {
    

  12.     const char *pIndex = strchr(str, c);
    

  13.     if(pIndex == NULL)
    

  14.         return -1;
    

  15.     else
    

  16.         return (pIndex - str);
    

  17. }
    


  18. 

  19. /* Base64加密 */
    

  20. uint32_t base64_encode(const unsigned char *sourceData, char *outputData ,int len)
    

  21. {
    

  22.     uint8_t index = 0;
    

  23.     int i=0, j=0;
    


  24. 

  25.     //每三组一个进行编码
    

  26.     for(; i < len; i += 3)
    

  27.     {
    

  28.         //第一个字节，根据源字节的第一个字节处理。 规则：源第一字节右移两位，去掉低2位，高2位补零。
    

  29.         index = ((sourceData[i] >> 2) & 0x3f);
    

  30.         outputData[j++] = base64char[index];
    


  31. 

  32.         //第二个字节，根据源字节的第一个字节和第二个字节联合处理。规则:第一个字节高6位去掉然后左移四位，第二个字节右移四位
    

  33.         //即：源第一字节低2位 + 源第2字节高4位
    

  34.         index = ((sourceData[i] << 4) & 0x30);
    

  35.         if(i+1 < len)
    

  36.         {
    

  37.             index |= ((sourceData[i + 1] >> 4) & 0x0f);
    

  38.             outputData[j++] = base64char[index];
    

  39.         }
    

  40.         else
    

  41.         {
    

  42.             outputData[j++] = base64char[index];
    

  43.             outputData[j++] = '=';
    

  44.             outputData[j++] = '=';
    


  45. 

  46.             break;//超出总长可以直接break
    

  47.         }
    


  48. 

  49.         //第三个字节，根据源字节的第二个字节和第三个字节联合处理，
    

  50.         //规则:第二个字节去掉高4位并左移两位（得高6位），第三个字节右移6位并去掉高6位（得低2位），相加即可
    

  51.         index = ((sourceData[i + 1] << 2) & 0x3c);
    

  52.         if((i + 2) < len)
    

  53.         {
    

  54.             index |= ((sourceData[i + 2] >> 6) & 0x03);
    

  55.             outputData[j++] = base64char[index];
    


  56. 

  57.             //第四个字节，规则:源第三字节去掉高2位即可
    

  58.             index = sourceData[i + 2] & 0x3f;
    

  59.             outputData[j++] = base64char[index];
    

  60.         }
    

  61.         else
    

  62.         {
    

  63.             outputData[j++] = base64char[index];
    

  64.             outputData[j++] = '=';
    


  65. 

  66.             break;
    

  67.         }
    

  68.     }
    


  69. 

  70.     outputData[j] = '\0';
    


  71. 

  72.     return 0;
    

  73. }
    

  74. /* Base64解密 */
    

  75. uint32_t base64_decode(const char *base64, unsigned char * deData)
    

  76. {
    

  77.     int i = 0, j = 0;
    

  78.     int trans[4] = {0};
    

  79.     for (; base64[i] != '\0'; i += 4)
    


  80. 

  81.     {
    

  82.         //获取第一与第二个字符，在base表中的索引值
    

  83.         trans[0] = charIndex(base64char, base64[i]);
    

  84.         trans[1] = charIndex(base64char, base64[i+1]);
    


  85. 

  86.         // 1/3
    

  87.         deData[j++] = ((trans[0] << 2) & 0xfc) | ((trans[1] >> 4) & 0x03);
    

  88.         if (base64[i + 2] == '=')
    

  89.             continue;
    

  90.         else
    

  91.             trans[2] = charIndex(base64char, base64[i + 2]);
    


  92. 

  93.         // 2/3
    

  94.         deData[j++] = ((trans[1] << 4) & 0xf0) | ((trans[2] >> 2) & 0x0f);
    

  95.         if (base64[i + 3] == '=')
    

  96.             continue;
    

  97.         else
    

  98.             trans[3] = charIndex(base64char, base64[i + 3]);
    


  99. 

  100.         // 3/3
    

  101.         deData[j++] = ((trans[2] << 6) & 0xc0) | (trans[3] & 0x3f);
    

  102.     }
    


  103. 

  104.     deData[j] = '\0';
    

  105.     return j;
    

  106. }
    


  107. 


  108. 


  109. 


  110. 


  111.


回复 赏

举报

gygp 发表于 2021-10-3 20:07 | 显示全部楼层
base64网上有 可以参考吧。   
回复 赏

举报

chenci2013 发表于 2021-10-3 20:07 | 显示全部楼层
加密的速度怎么样      
回复 赏

举报

biechedan 发表于 2021-10-3 20:07 | 显示全部楼层
是用的库函数吗？   
回复 赏

举报

wangdezhi 发表于 2021-10-3 20:07 | 显示全部楼层
有sha1加密的算法吗   
回复 赏

举报

isseed 发表于 2021-10-3 20:08 | 显示全部楼层
上位机带有界面功能吗？   
回复 赏

举报

xietingfeng 发表于 2021-10-3 20:08 | 显示全部楼层
对秘钥有什么要求吗？   
回复 赏

举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

liupk
个人签名：安得广厦电子科技

34

主题

442

帖子

5

粉丝
快速回复 在线客服 返回列表 返回顶部
liupk
个人签名：安得广厦电子科技

34

主题

442

帖子

5

粉丝
快速回复 在线客服 返回列表 返回顶部