21ic电子技术开发论坛 › 单片机与嵌入式系统 › 国民技术MCU › 【N32G457】AES加密解密测试
返回列表 发新帖我要提问

[N32G45x] 【N32G457】AES加密解密测试

[复制链接]
 楼主| aple0807 发表于 2022-2-13 10:39 | 显示全部楼层 |阅读模式
MCU, AES, 测试, AES加密, 加密解密, N32G457
本帖最后由 aple0807 于 2022-2-13 10:42 编辑

之前看国民系列MCU支持硬件加密解码模块，可惜本开发板MCU没有该功能，测下软件加密解密速度及用法。
下面主要测试 AES 和 DES。

AES加密模式比较多，代码如下：
复制
  1. void aes_demo(void)
    

  2. {
    

  3.         uu32 clk_start;
    

  4.         uu8 *src, *enc, *dec, *iv;
    

  5.         mbedtls_aes_context *aes_enc, *aes_dec;
    

  6.         size_t offset;
    


  7. 

  8.         // 内存请求
    

  9.         src = calloc(1, 1024);
    

  10.         enc = calloc(1, 1024);
    

  11.         dec = calloc(1, 1024);
    

  12.         iv = calloc(1, 80);
    

  13.         aes_enc = malloc(sizeof(mbedtls_aes_context));
    

  14.         aes_dec = malloc(sizeof(mbedtls_aes_context));
    


  15. 

  16.         dbg_puts("\n===========================================================\n");
    

  17.         dbg_print("AES 128 encode test: <128 bits> \n");
    


  18. 

  19.         // 初始化
    

  20.         dat_buff_init();
    


  21. 

  22.         // 初始化结构
    

  23.         mbedtls_aes_init(aes_enc);
    

  24.         mbedtls_aes_init(aes_dec);
    


  25. 

  26.         // 生成 KEY
    

  27.         clk_start = bsp_cpu_clks_get();
    

  28.         mbedtls_aes_setkey_enc(aes_enc, (void *)ase_key_src, 128);
    

  29.         mbedtls_aes_setkey_dec(aes_dec, (void *)ase_key_src, 128);
    

  30.         dbg_print("key make time: %d us\n", bsp_clks_to_us(bsp_cpu_clks_get() - clk_start));
    


  31. 

  32.         /*------------------------------------------------------------------------*/
    

  33.         // 加密 + 解密         ECB                        电子密码本模式
    

  34.         clk_start = bsp_cpu_clks_get();
    

  35.         mbedtls_aes_crypt_ecb(aes_enc, MBEDTLS_AES_ENCRYPT, src, enc);
    

  36.         mbedtls_aes_crypt_ecb(aes_dec, MBEDTLS_AES_DECRYPT, enc, dec);
    

  37.         dbg_print("AES ecb : enc + dec time: %d us\n", bsp_clks_to_us(bsp_cpu_clks_get() - clk_start));
    


  38. 

  39.         // 显示
    

  40.         //dbg_u8_print("src: ", src, 16, 20);
    

  41.         dbg_u8_print("enc: ", enc, 16, 20);
    

  42.         dbg_u8_print("dec: ", dec, 16, 20);
    


  43. 

  44.         /*------------------------------------------------------------------------*/
    

  45.         // 加密 + 解密         CBC                        密码分组连接模式        - 内部分组 IO长度相同
    

  46.         // 加密解密需要相同的初始向量, 向量长度16B
    

  47.         dat_buff_init();
    

  48.         clk_start = bsp_cpu_clks_get();
    


  49. 

  50.         memset(iv, 0xFF, 16);
    

  51.         mbedtls_aes_crypt_cbc(aes_enc, MBEDTLS_AES_ENCRYPT, 512, iv, src, enc);
    


  52. 

  53.         memset(iv, 0xFF, 16);
    

  54.         mbedtls_aes_crypt_cbc(aes_dec, MBEDTLS_AES_DECRYPT, 512, iv, enc, dec);
    


  55. 

  56.         dbg_print("\nAES CBC 512 : enc + dec time: %d us\n", bsp_clks_to_us(bsp_cpu_clks_get() - clk_start));
    


  57. 

  58.         // 显示
    

  59.         //dbg_u8_print("src: \n", src, 64, 32);
    

  60.         dbg_u8_print("enc: \n", enc, 128, 32);
    

  61.         dbg_u8_print("dec: \n", dec, 128, 32);
    


  62. 

  63.         /*------------------------------------------------------------------------*/
    

  64.         // 加密 + 解密         CFB8                密文反馈模式                - 内部分组 IO长度相同
    

  65.         // 加密解密需要相同的初始向量, 向量长度16B，加密解密都使用加密器
    

  66.         dat_buff_init();
    

  67.         mbedtls_aes_setkey_enc(aes_enc, (void *)ase_key_src, 128);
    

  68.         clk_start = bsp_cpu_clks_get();
    

  69.         memset(iv, 0xFF, 16);
    

  70.         mbedtls_aes_crypt_cfb8(aes_enc, MBEDTLS_AES_ENCRYPT, 60, iv, src, enc);
    

  71.         memset(iv, 0xFF, 16);
    

  72.         mbedtls_aes_crypt_cfb8(aes_enc, MBEDTLS_AES_DECRYPT, 60, iv, enc, dec);
    

  73.         dbg_print("\nAES CFB8 60 : enc + dec time: %d us\n", bsp_clks_to_us(bsp_cpu_clks_get() - clk_start));
    


  74. 

  75.         // 显示
    

  76.         //dbg_u8_print("src: \n", src, 64, 32);
    

  77.         dbg_u8_print("enc: \n", enc, 64, 32);
    

  78.         dbg_u8_print("dec: \n", dec, 64, 32);
    


  79. 

  80.         /*------------------------------------------------------------------------*/
    

  81.         // 加密 + 解密         CFB128                密文反馈模式                - 内部分组 IO长度相同
    

  82.         // 加密解密需要相同的初始向量, 向量长度16B，加密解密都使用加密器
    

  83.         dat_buff_init();
    

  84.         offset = 8; // 0~15
    

  85.         clk_start = bsp_cpu_clks_get();
    


  86. 

  87.         memset(iv, 0xFF, 16);
    

  88.         mbedtls_aes_setkey_enc(aes_enc, (void *)ase_key_src, 128);
    

  89.         mbedtls_aes_crypt_cfb128(aes_enc, MBEDTLS_AES_ENCRYPT, 512, &offset, iv, src, enc);
    


  90. 

  91.         memset(iv, 0xFF, 16);
    

  92.         mbedtls_aes_setkey_enc(aes_enc, (void *)ase_key_src, 128);
    

  93.         mbedtls_aes_crypt_cfb128(aes_enc, MBEDTLS_AES_DECRYPT, 512, &offset, iv, enc, dec);
    


  94. 

  95.         dbg_print("\nAES CFB128 512 : enc + dec time: %d us\n", bsp_clks_to_us(bsp_cpu_clks_get() - clk_start));
    


  96. 

  97.         // 显示
    

  98.         //dbg_u8_print("src: \n", src, 64, 32);
    

  99.         dbg_u8_print("enc: \n", enc, 64, 32);
    

  100.         dbg_u8_print("dec: \n", dec, 64, 32);
    


  101. 

  102.         /*------------------------------------------------------------------------*/
    

  103.         // 加密 + 解密         OFB                输出反馈模式
    

  104.         // 加密解密需要相同的初始向量, 向量长度16B，加密解密都使用加密器
    

  105.         dat_buff_init();
    

  106.         offset = 8; // 0~15
    

  107.         clk_start = bsp_cpu_clks_get();
    


  108. 

  109.         memset(iv, 0xFF, 16);
    

  110.         mbedtls_aes_setkey_enc(aes_enc, (void *)ase_key_src, 128);
    

  111.         mbedtls_aes_crypt_ofb(aes_enc, 512, &offset, iv, src, enc);
    


  112. 

  113.         memset(iv, 0xFF, 16);
    

  114.         mbedtls_aes_setkey_enc(aes_enc, (void *)ase_key_src, 128);
    

  115.         mbedtls_aes_crypt_ofb(aes_enc, 512, &offset, iv, enc, dec);
    


  116. 

  117.         dbg_print("\nAES OFB 512 : enc + dec time: %d us\n", bsp_clks_to_us(bsp_cpu_clks_get() - clk_start));
    


  118. 

  119.         // 显示
    

  120.         //dbg_u8_print("src: \n", src, 64, 32);
    

  121.         dbg_u8_print("enc: \n", enc, 64, 32);
    

  122.         dbg_u8_print("dec: \n", dec, 64, 32);
    


  123. 

  124.         // 释放，用于清除内存中的密匙，属于安全性代码
    

  125.         mbedtls_aes_free(aes_enc);
    

  126.         mbedtls_aes_free(aes_dec);
    


  127. 

  128.         // 释放内存
    

  129.         free(src);
    

  130.         free(enc);
    

  131.         free(dec);
    

  132.         free(iv);
    

  133.         free(aes_enc);
    

  134.         free(aes_dec);
    

  135. }


DES测试：
复制
  1. void des_demo(void)
    

  2. {
    

  3.         uu32 clk_start;
    


  4. 

  5.         uu8 *src, *enc, *dec;
    

  6.         mbedtls_des_context *mbed_des_enc;
    

  7.         mbedtls_des_context *mbed_des_dec;
    


  8. 

  9.         // 内存请求
    

  10.         src = calloc(1, 80);
    

  11.         enc = calloc(1, 80);
    

  12.         dec = calloc(1, 80);
    

  13.         mbed_des_enc = calloc(1, sizeof(mbedtls_des_context));
    

  14.         mbed_des_dec = calloc(1, sizeof(mbedtls_des_context));
    


  15. 

  16.         dbg_puts("\n===========================================================\n");
    

  17.         dbg_print("mbed DES 64 test :\n");
    

  18.         memcpy(src, led_code, 8);
    

  19.         //memset(ptr, 0x53, 8);
    


  20. 

  21.         mbedtls_des_init(mbed_des_enc);
    

  22.         mbedtls_des_init(mbed_des_dec);
    


  23. 

  24.         // mbed des key creat
    

  25.         clk_start = bsp_cpu_clks_get();
    

  26.         mbedtls_des_setkey_enc(mbed_des_enc, (void *)"12345678");
    

  27.         mbedtls_des_setkey_dec(mbed_des_dec, (void *)"12345678");
    

  28.         dbg_print("key make time: %d us\n", bsp_clks_to_us(bsp_cpu_clks_get() - clk_start));
    


  29. 

  30.         // enc dec
    

  31.         clk_start = bsp_cpu_clks_get();
    

  32.         mbedtls_des_crypt_ecb(mbed_des_enc, src, enc);
    

  33.         mbedtls_des_crypt_ecb(mbed_des_dec, enc, dec);
    

  34.         dbg_print("enc and dec time: %d us\n", bsp_clks_to_us(bsp_cpu_clks_get() - clk_start));
    


  35. 

  36.         // displsy
    

  37.         dbg_u8_print("src: ", src, 8, 12);
    

  38.         dbg_u8_print("enc: ", enc, 8, 12);
    

  39.         dbg_u8_print("dec: ", dec, 8, 12);
    


  40. 

  41.         // 清除内存关键数据
    

  42.         mbedtls_des_free(mbed_des_enc);
    

  43.         mbedtls_des_free(mbed_des_dec);
    


  44. 

  45.         // 释放内存
    

  46.         free(src);
    

  47.         free(enc);
    

  48.         free(dec);
    

  49.         free(mbed_des_enc);
    

  50.         free(mbed_des_dec);
    

  51. }

测试结果
复制
  1. AES 128 encode test: <128 bits> 
    

  2. key make time: 454 us
    

  3. AES ecb : enc + dec time: 22 us
    

  4. enc: 39 5B AB C7 F2 72 0A AA F6 12 15 58 39 86 95 FF 
    

  5. dec: 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 
    


  6. 

  7. AES CBC 512 : enc + dec time: 807 us
    

  8. enc: 
    

  9. 22 F6 8C 6E 7B B0 B5 53 AA 2C 24 36 58 E8 C6 DB 0D B2 B7 A7 11 D6 C9 65 F9 96 2B 40 14 A0 86 6A  =>line#1
    

  10. D2 6C 10 6E 07 B0 B2 50 C8 36 0B 56 3F A8 CE 33 D5 CC E4 60 4A 63 EE 52 9C 4A 14 33 82 D4 45 28  =>line#2
    

  11. C5 28 05 5D 4D B7 72 B1 6F 8A F1 C8 5C 9B B9 6C 95 9F 76 40 88 EF D5 D9 53 1F 9B 98 BE EA 3B 54  =>line#3
    

  12. 8C 5A 9C 12 E6 F9 DA FF 57 40 A7 46 D4 89 AD 72 44 AA 10 CB FF 12 52 56 37 B8 CA 42 57 54 6D CC  =>line#4
    

  13. dec: 
    

  14. 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F  =>line#1
    

  15. 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F  =>line#2
    

  16. 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F  =>line#3
    

  17. 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F  =>line#4
    


  18. 

  19. AES CFB8 60 : enc + dec time: 1391 us
    

  20. enc: 
    

  21. 83 EE 6E 28 BB 81 0A AC C6 50 74 E8 D7 F9 5D 88 9D 7B 71 31 35 00 43 6B 43 7F 1D 6D CE BD 7B B2  =>line#1
    

  22. 0E E6 4C 56 0A 06 59 2B D0 5B 8C 1C 04 15 55 A8 08 1E 97 91 81 D2 1E 55 27 93 DF F0 00 00 00 00  =>line#2
    

  23. dec: 
    

  24. 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F  =>line#1
    

  25. 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 00 00 00 00  =>line#2
    


  26. 

  27. AES CFB128 512 : enc + dec time: 901 us
    

  28. enc: 
    

  29. FF FE FD FC FB FA F9 F8 30 86 76 38 13 31 D3 CA C1 E2 A1 D4 C5 A9 64 5E D3 7E 48 C7 92 D4 47 3D  =>line#1
    

  30. 93 3E 3E 95 21 27 BC 8F 74 FD 9A 70 74 2A 94 74 44 4A E8 79 4A EF A2 8D 91 DC CB C9 4A 5E 6D 3A  =>line#2
    

  31. dec: 
    

  32. 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F  =>line#1
    

  33. 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F  =>line#2
    


  34. 

  35. AES OFB 512 : enc + dec time: 863 us
    

  36. enc: 
    

  37. FF FE FD FC FB FA F9 F8 8B CA FF BB 07 FC 73 5A A0 A5 53 25 65 7D D8 9A 64 9B 3E 77 AD F0 99 C4  =>line#1
    

  38. 9A 36 0B 7F 5F 27 D3 57 B5 31 E2 EF FF E1 C0 13 C3 A3 A7 13 77 22 07 E5 9D 9F FB 63 27 45 90 80  =>line#2
    

  39. dec: 
    

  40. 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F  =>line#1
    

  41. 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F  =>line#2
    


  42. 

  43. ===========================================================
    

  44. mbed DES 64 test :
    

  45. key make time: 70 us
    

  46. enc and dec time: 27 us
    

  47. src: 3F 06 5B 4F 66 6D 7D 07 
    

  48. enc: 27 94 E5 83 D9 76 42 6F 
    

  49. dec: 3F 06 5B 4F 66 6D 7D 07
需要注意的是AES加密需要的堆栈比较大，建议任务堆栈分配3KB以上。
测试结果比预想的要好的多，AES加解密速度大约700KB/s.

另外，初始化代码默认开启了指令cache加速，关闭该功能进行测试，速度相差30%左右。

下面附上测试KEIL工程：
software.rar (3.48 MB, 下载次数: 20)
回复 赏

举报

相关帖子
chenjun89 发表于 2022-2-14 08:16 来自手机 | 显示全部楼层
还没用过加解密
回复 赏

举报

内政奇才 发表于 2022-2-14 10:12 来自手机 | 显示全部楼层
感谢楼主分享
回复 赏

举报

gouguoccc 发表于 2022-2-15 19:10 来自手机 | 显示全部楼层
计算速度快嘛
回复 赏

举报

 楼主| aple0807 发表于 2022-2-16 11:42 | 显示全部楼层
gouguoccc 发表于 2022-2-15 19:10
计算速度快嘛

还可以，ECB模式，加密+解密一包数据22us，换算约700KB/s
回复 赏

举报

海滨消消 发表于 2022-2-16 15:26 来自手机 | 显示全部楼层
这计算速度还是可以的
回复 赏

举报

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

本版积分规则

aple0807

77

主题

326

帖子

2

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