21ic电子技术开发论坛 › 单片机与嵌入式系统 › 国民技术MCU › 【N32G45XVL-STB_V1.1】开发板评测2: 硬件密码单元测试 ...
返回列表 发新帖我要提问

[N32G45x] 【N32G45XVL-STB_V1.1】开发板评测2: 硬件密码单元测试

[复制链接]
 楼主| zhanzr21 发表于 2022-2-7 20:45 | 显示全部楼层 |阅读模式
对称加密, sha256, 商用密码, 随机数, 硬件加速
国民技术的主要产品是专用加密芯片, 如U盾, 各种充值卡, 银**, 会员卡上的芯片. 这些芯片上都会涉及到加解密. 所以通用芯片上也有硬件加密单元也就不为奇.

根据用户手册, N32G457上的支持的硬件加密算法有:

算法支持 DES/3DES、 AES、 SHA1/SHA224/SHA256、 SM1、 SM3、 SM4F、 SM7、 MD5、 CRC16/CRC32、 TRNG
给对密码算法不熟的坛友简介一下子:

DES/3DES
这是对称加解密算法, 属于比较老的的算法种类, 目前已经在淘汰的边缘, 但是很多老产品还在使用. 之所以要淘汰, 是因为目前的硬件发展使得暴力**DES成本很低了.所谓对称算法是相对于非对称算法来说的, 对称算法中, 加解密过程是对称的, 密钥是通用的. 非对称算法中有私钥公钥之分. 非对称算法比对称算法要复杂, 所以手上拿的这个芯片没有相应的硬件加速单元, 成本和功能的平衡.
3DES是DES算法接连做三次, 增加暴力**成本, 其实也只是加个补丁. 目前有更好的算法供选择, 新产品中不建议使用DES/3DES算法.

AES
刚刚说到DES/3DES目前属于被淘汰的算法, AES就是主要替代算法. 理解为DES/3DES的升级版本即可.

SHA1/SHA224/SHA256/MD5

这都是哈希算法, 也叫散列算法, SHA1和MD5属于要淘汰的算法, 新产品不建议使用, 原因也是目前硬件暴力**的成本下降, 不安全.

SM1/SM4F/SM7

国家密码局颁布的商用密码, 都是对称算法, 用于商业金融领域, 简单理解为DES/3DES/AES的国内替代品即可.

SM3
SHA256的国内替代算法.


目前密码学界的共识是: SM系列算法安全度高于AES/SHA256系列. 但是AES/SH256是国际通用的, 遇到的可能性更大.

另外, S * M 是 商用密码的商密二字的汉语拼音缩写. 不知道论坛发贴让不让发, 有点歧义.

这些算法都可以用软件来实现, 但是用硬件实现后性能要高一点. 比如DES-EBC简单数百行即可实现. (EBC是对称加密算法的模式代号).
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <string.h>
    

  4.  
    

  5. typedef unsigned char ubyte;
    

  6.  
    

  7. #define KEY_LEN 8
    

  8. typedef ubyte simple_des_key_t[KEY_LEN];
    

  9.  
    

  10. const static ubyte PC1[] = {
    

  11.     57, 49, 41, 33, 25, 17,  9,
    

  12.      1, 58, 50, 42, 34, 26, 18,
    

  13.     10,  2, 59, 51, 43, 35, 27,
    

  14.     19, 11,  3, 60, 52, 44, 36,
    

  15.     63, 55, 47, 39, 31, 23, 15,
    

  16.      7, 62, 54, 46, 38, 30, 22,
    

  17.     14,  6, 61, 53, 45, 37, 29,
    

  18.     21, 13,  5, 28, 20, 12,  4
    

  19. };
    

  20.  
    

  21. const static ubyte PC2[] = {
    

  22.     14, 17, 11, 24,  1,  5,
    

  23.      3, 28, 15,  6, 21, 10,
    

  24.     23, 19, 12,  4, 26,  8,
    

  25.     16,  7, 27, 20, 13,  2,
    

  26.     41, 52, 31, 37, 47, 55,
    

  27.     30, 40, 51, 45, 33, 48,
    

  28.     44, 49, 39, 56, 34, 53,
    

  29.     46, 42, 50, 36, 29, 32
    

  30. };
    

  31.  
    

  32. const static ubyte IP[] = {
    

  33.     58, 50, 42, 34, 26, 18, 10,  2,
    

  34.     60, 52, 44, 36, 28, 20, 12,  4,
    

  35.     62, 54, 46, 38, 30, 22, 14,  6,
    

  36.     64, 56, 48, 40, 32, 24, 16,  8,
    

  37.     57, 49, 41, 33, 25, 17,  9,  1,
    

  38.     59, 51, 43, 35, 27, 19, 11,  3,
    

  39.     61, 53, 45, 37, 29, 21, 13,  5,
    

  40.     63, 55, 47, 39, 31, 23, 15,  7
    

  41. };
    

  42.  
    

  43. const static ubyte E[] = {
    

  44.     32,  1,  2,  3,  4,  5,
    

  45.      4,  5,  6,  7,  8,  9,
    

  46.      8,  9, 10, 11, 12, 13,
    

  47.     12, 13, 14, 15, 16, 17,
    

  48.     16, 17, 18, 19, 20, 21,
    

  49.     20, 21, 22, 23, 24, 25,
    

  50.     24, 25, 26, 27, 28, 29,
    

  51.     28, 29, 30, 31, 32,  1
    

  52. };
    

  53.  
    

  54. const static ubyte S[][64] = {
    

  55.     {
    

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

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

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

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

  60.     },
    

  61.     {
    

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

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

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

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

  66.     },
    

  67.     {
    

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

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

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

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

  72.     },
    

  73.     {
    

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

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

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

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

  78.     },
    

  79.     {
    

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

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

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

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

  84.     },
    

  85.     {
    

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

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

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

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

  90.     },
    

  91.     {
    

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

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

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

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

  96.     },
    

  97.     {
    

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

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

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

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

  102.     }
    

  103. };
    

  104.  
    

  105. const static ubyte P[] = {
    

  106.     16,  7, 20, 21,
    

  107.     29, 12, 28, 17,
    

  108.      1, 15, 23, 26,
    

  109.      5, 18, 31, 10,
    

  110.      2,  8, 24, 14,
    

  111.     32, 27,  3,  9,
    

  112.     19, 13, 30,  6,
    

  113.     22, 11,  4, 25
    

  114. };
    

  115.  
    

  116. const static ubyte IP2[] = {
    

  117.     40,  8, 48, 16, 56, 24, 64, 32,
    

  118.     39,  7, 47, 15, 55, 23, 63, 31,
    

  119.     38,  6, 46, 14, 54, 22, 62, 30,
    

  120.     37,  5, 45, 13, 53, 21, 61, 29,
    

  121.     36,  4, 44, 12, 52, 20, 60, 28,
    

  122.     35,  3, 43, 11, 51, 19, 59, 27,
    

  123.     34,  2, 42, 10, 50, 18, 58, 26,
    

  124.     33,  1, 41,  9, 49, 17, 57, 25
    

  125. };
    

  126.  
    

  127. const static ubyte SHIFTS[] = {
    

  128.     1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
    

  129. };
    

  130.  
    

  131. typedef struct {
    

  132.     ubyte *data;
    

  133.     int len;
    

  134. } String;
    

  135.  
    

  136. /*
    

  137.  * Transform a single nibble into a hex character
    

  138.  *
    

  139.  * in: a value < 0x10
    

  140.  *
    

  141.  * returns: the character that represents the nibble
    

  142.  */
    

  143. static char toHex(ubyte in) {
    

  144.     if (0x00 <= in && in < 0x0A) {
    

  145.         return '0' + in;
    

  146.     }
    

  147.     if (0x0A <= in && in <= 0x0F) {
    

  148.         return 'A' + in - 0x0A;
    

  149.     }
    

  150.     return 0;
    

  151. }
    

  152.  
    

  153. /*
    

  154.  * Convert an array of bytes into a string
    

  155.  *
    

  156.  * ptr: the array of bytes
    

  157.  * len: the number of bytes
    

  158.  * out: a buffer allocated by the caller with enough space for 2*len+1 characters
    

  159.  */
    

  160. static void printBytes(const ubyte *ptr, int len, char *out) {
    

  161.     while (len-- > 0) {
    

  162.         *out++ = toHex(*ptr >> 4);
    

  163.         *out++ = toHex(*ptr & 0x0F);
    

  164.  
    

  165.         ptr++;
    

  166.     }
    

  167.     *out = 0;
    

  168. }
    

  169.  
    

  170. /*
    

  171.  * Gets the value of a bit in an array of bytes
    

  172.  *
    

  173.  * src: the array of bytes to index
    

  174.  * index: the desired bit to test the value of
    

  175.  *
    

  176.  * returns: the bit at the specified position in the array
    

  177.  */
    

  178. static int peekBit(const ubyte *src, int index) {
    

  179.     int cell = index / 8;
    

  180.     int bit = 7 - index % 8;
    

  181.     return (src[cell] & (1 << bit)) != 0;
    

  182. }
    

  183.  
    

  184. /*
    

  185.  * Sets the value of a bit in an array of bytes
    

  186.  *
    

  187.  * dst: the array of bits to set a bit in
    

  188.  * index: the position of the bit to set
    

  189.  * value: the value for the bit to set
    

  190.  */
    

  191. static void pokeBit(ubyte *dst, int index, int value) {
    

  192.     int cell = index / 8;
    

  193.     int bit = 7 - index % 8;
    

  194.     if (value == 0) {
    

  195.         dst[cell] &= ~(1 << bit);
    

  196.     } else {
    

  197.         dst[cell] |= (1 << bit);
    

  198.     }
    

  199. }
    

  200.  
    

  201. /*
    

  202.  * Transforms one array of bytes by shifting the bits the specified number of positions
    

  203.  *
    

  204.  * src: the array to shift bits from
    

  205.  * len: the length of the src array
    

  206.  * times: the number of positions that the bits should be shifted
    

  207.  * dst: a bytes array allocated by the caller to store the shifted values
    

  208.  */
    

  209. static void shiftLeft(const ubyte *src, int len, int times, ubyte *dst) {
    

  210.     int i, t;
    

  211.     for (i = 0; i <= len; ++i) {
    

  212.         pokeBit(dst, i, peekBit(src, i));
    

  213.     }
    

  214.     for (t = 1; t <= times; ++t) {
    

  215.         int temp = peekBit(dst, 0);
    

  216.         for (i = 1; i <= len; ++i) {
    

  217.             pokeBit(dst, i - 1, peekBit(dst, i));
    

  218.         }
    

  219.         pokeBit(dst, len - 1, temp);
    

  220.     }
    

  221. }
    

  222.  
    

  223. /*
    

  224.  * Calculates the sub keys to be used in processing the messages
    

  225.  *
    

  226.  * key: the array of bytes representing the key
    

  227.  * ks: the subkeys that have been allocated by the caller
    

  228.  */
    

  229. typedef ubyte subkey_t[17][6]; /* 17 sets of 48 bits */
    

  230. static void getSubKeys(const simple_des_key_t key, subkey_t ks) {
    

  231.     ubyte c[17][7];  /* 56 bits */
    

  232.     ubyte d[17][4];  /* 28 bits */
    

  233.     ubyte kp[7];
    

  234.     int i, j;
    

  235.  
    

  236.     /* intialize */
    

  237.     memset(c, 0, sizeof(c));
    

  238.     memset(d, 0, sizeof(d));
    

  239.     memset(ks, 0, sizeof(subkey_t));
    

  240.  
    

  241.     /* permute 'key' using table PC1 */
    

  242.     for (i = 0; i < 56; ++i) {
    

  243.         pokeBit(kp, i, peekBit(key, PC1[i] - 1));
    

  244.     }
    

  245.  
    

  246.     /* split 'kp' in half and process the resulting series of 'c' and 'd' */
    

  247.     for (i = 0; i < 28; ++i) {
    

  248.         pokeBit(c[0], i, peekBit(kp, i));
    

  249.         pokeBit(d[0], i, peekBit(kp, i + 28));
    

  250.     }
    

  251.  
    

  252.     /* shift the components of c and d */
    

  253.     for (i = 1; i < 17; ++i) {
    

  254.         shiftLeft(c[i - 1], 28, SHIFTS[i - 1], c[i]);
    

  255.         shiftLeft(d[i - 1], 28, SHIFTS[i - 1], d[i]);
    

  256.     }
    

  257.  
    

  258.     /* merge 'd' into 'c' */
    

  259.     for (i = 1; i < 17; ++i) {
    

  260.         for (j = 28; j < 56; ++j) {
    

  261.             pokeBit(c[i], j, peekBit(d[i], j - 28));
    

  262.         }
    

  263.     }
    

  264.  
    

  265.     /* form the sub-keys and store them in 'ks'
    

  266.      * permute 'c' using table PC2 */
    

  267.     for (i = 1; i < 17; ++i) {
    

  268.         for (j = 0; j < 48; ++j) {
    

  269.             pokeBit(ks[i], j, peekBit(c[i], PC2[j] - 1));
    

  270.         }
    

  271.     }
    

  272. }
    

  273.  
    

  274. /*
    

  275.  * Function used in processing the messages
    

  276.  *
    

  277.  * r: an array of bytes to be processed
    

  278.  * ks: one of the subkeys to be used for processing
    

  279.  * sp: output from the processing
    

  280.  */
    

  281. static void f(ubyte *r, ubyte *ks, ubyte *sp) {
    

  282.     ubyte er[6]; /* 48 bits */
    

  283.     ubyte sr[4]; /* 32 bits */
    

  284.     int i;
    

  285.  
    

  286.     /* initialize */
    

  287.     memset(er, 0, sizeof(er));
    

  288.     memset(sr, 0, sizeof(sr));
    

  289.  
    

  290.     /* permute 'r' using table E */
    

  291.     for (i = 0; i < 48; ++i) {
    

  292.         pokeBit(er, i, peekBit(r, E[i] - 1));
    

  293.     }
    

  294.  
    

  295.     /* xor 'er' with 'ks' and store back into 'er' */
    

  296.     for (i = 0; i < 6; ++i) {
    

  297.         er[i] ^= ks[i];
    

  298.     }
    

  299.  
    

  300.     /* process 'er' six bits at a time and store resulting four bits in 'sr' */
    

  301.     for (i = 0; i < 8; ++i) {
    

  302.         int j = i * 6;
    

  303.         int b[6];
    

  304.         int k, row, col, m, n;
    

  305.  
    

  306.         for (k = 0; k < 6; ++k) {
    

  307.             b[k] = peekBit(er, j + k) != 0 ? 1 : 0;
    

  308.         }
    

  309.  
    

  310.         row = 2 * b[0] + b[5];
    

  311.         col = 8 * b[1] + 4 * b[2] + 2 * b[3] + b[4];
    

  312.         m = S[i][row * 16 + col]; /* apply table s */
    

  313.         n = 1;
    

  314.  
    

  315.         while (m > 0) {
    

  316.             int p = m % 2;
    

  317.             pokeBit(sr, (i + 1) * 4 - n, p == 1);
    

  318.             m /= 2;
    

  319.             n++;
    

  320.         }
    

  321.     }
    

  322.  
    

  323.     /* permute sr using table P */
    

  324.     for (i = 0; i < 32; ++i) {
    

  325.         pokeBit(sp, i, peekBit(sr, P[i] - 1));
    

  326.     }
    

  327. }
    

  328.  
    

  329. /*
    

  330.  * Processing of block of the message
    

  331.  *
    

  332.  * message: an 8 byte block from the message
    

  333.  * ks: the subkeys to use in processing
    

  334.  * ep: space for an encoded 8 byte block allocated by the caller
    

  335.  */
    

  336. static void processMessage(const ubyte *message, subkey_t ks, ubyte *ep) {
    

  337.     ubyte left[17][4];  /* 32 bits */
    

  338.     ubyte right[17][4]; /* 32 bits */
    

  339.     ubyte mp[8];        /* 64 bits */
    

  340.     ubyte e[8];         /* 64 bits */
    

  341.     int i, j;
    

  342.  
    

  343.     /* permute 'message' using table IP */
    

  344.     for (i = 0; i < 64; ++i) {
    

  345.         pokeBit(mp, i, peekBit(message, IP[i] - 1));
    

  346.     }
    

  347.  
    

  348.     /* split 'mp' in half and process the resulting series of 'l' and 'r */
    

  349.     for (i = 0; i < 32; ++i) {
    

  350.         pokeBit(left[0], i, peekBit(mp, i));
    

  351.         pokeBit(right[0], i, peekBit(mp, i + 32));
    

  352.     }
    

  353.     for (i = 1; i < 17; ++i) {
    

  354.         ubyte fs[4]; /* 32 bits */
    

  355.  
    

  356.         memcpy(left[i], right[i - 1], 4);
    

  357.         f(right[i - 1], ks[i], fs);
    

  358.         for (j = 0; j < 4; ++j) {
    

  359.             left[i - 1][j] ^= fs[j];
    

  360.         }
    

  361.         memcpy(right[i], left[i - 1], 4);
    

  362.     }
    

  363.  
    

  364.     /* amalgamate r[16] and l[16] (in that order) into 'e' */
    

  365.     for (i = 0; i < 32; ++i) {
    

  366.         pokeBit(e, i, peekBit(right[16], i));
    

  367.     }
    

  368.     for (i = 32; i < 64; ++i) {
    

  369.         pokeBit(e, i, peekBit(left[16], i - 32));
    

  370.     }
    

  371.  
    

  372.     /* permute 'e' using table IP2 ad return result as a hex string */
    

  373.     for (i = 0; i < 64; ++i) {
    

  374.         pokeBit(ep, i, peekBit(e, IP2[i] - 1));
    

  375.     }
    

  376. }
    

  377.  
    

  378. /*
    

  379.  * Encrypts a message using DES
    

  380.  *
    

  381.  * key: the key to use to encrypt the message
    

  382.  * message: the message to be encrypted
    

  383.  * len: the length of the message
    

  384.  *
    

  385.  * returns: a paring of dynamically allocated memory for the encoded message,
    

  386.  *          and the length of the encoded message.
    

  387.  *          the caller will need to free the memory after use.
    

  388.  */
    

  389. String encrypt(const simple_des_key_t key, const ubyte *message, int len) {
    

  390.     String result = { 0, 0 };
    

  391.     subkey_t ks;
    

  392.     ubyte padByte;
    

  393.     int i;
    

  394.  
    

  395.     getSubKeys(key, ks);
    

  396.  
    

  397.     padByte = 8 - len % 8;
    

  398.     result.len = len + padByte;
    

  399.     result.data = (ubyte*)malloc(result.len);
    

  400.     memcpy(result.data, message, len);
    

  401.     memset(&result.data[len], padByte, padByte);
    

  402.  
    

  403.     for (i = 0; i < result.len; i += 8) {
    

  404.         processMessage(&result.data[i], ks, &result.data[i]);
    

  405.     }
    

  406.  
    

  407.     return result;
    

  408. }
    

  409.  
    

  410. /*
    

  411.  * Decrypts a message using DES
    

  412.  *
    

  413.  * key: the key to use to decrypt the message
    

  414.  * message: the message to be decrypted
    

  415.  * len: the length of the message
    

  416.  *
    

  417.  * returns: a paring of dynamically allocated memory for the decoded message,
    

  418.  *          and the length of the decoded message.
    

  419.  *          the caller will need to free the memory after use.
    

  420.  */
    

  421. String decrypt(const simple_des_key_t key, const ubyte *message, int len) {
    

  422.     String result = { 0, 0 };
    

  423.     subkey_t ks;
    

  424.     int i, j;
    

  425.     ubyte padByte;
    

  426.  
    

  427.     getSubKeys(key, ks);
    

  428.     /* reverse the subkeys */
    

  429.     for (i = 1; i < 9; ++i) {
    

  430.         for (j = 0; j < 6; ++j) {
    

  431.             ubyte temp = ks[i][j];
    

  432.             ks[i][j] = ks[17 - i][j];
    

  433.             ks[17 - i][j] = temp;
    

  434.         }
    

  435.     }
    

  436.  
    

  437.     result.data = (ubyte*)malloc(len);
    

  438.     memcpy(result.data, message, len);
    

  439.     result.len = len;
    

  440.     for (i = 0; i < result.len; i += 8) {
    

  441.         processMessage(&result.data[i], ks, &result.data[i]);
    

  442.     }
    

  443.  
    

  444.     padByte = result.data[len - 1];
    

  445.     result.len -= padByte;
    

  446.     return result;
    

  447. }
    

  448.  
    

  449. /*
    

  450.  * Convienience method for showing the round trip processing of a message
    

  451.  */
    

  452. void driver(const simple_des_key_t key, const ubyte *message, int len) {
    

  453.     String encoded, decoded;
    

  454.     char buffer[128];
    

  455.  
    

  456.     printBytes(key, KEY_LEN, buffer);
    

  457.     printf("Key     : %s\n", buffer);
    

  458.  
    

  459.     printBytes(message, len, buffer);
    

  460.     printf("Message : %s\n", buffer);
    

  461.  
    

  462.     encoded = encrypt(key, message, len);
    

  463.     printBytes(encoded.data, encoded.len, buffer);
    

  464.     printf("Encoded : %s\n", buffer);
    

  465.  
    

  466.     decoded = decrypt(key, encoded.data, encoded.len);
    

  467.     printBytes(decoded.data, decoded.len, buffer);
    

  468.     printf("Decoded : %s\n\n", buffer);
    

  469.  
    

  470.     /* release allocated memory */
    

  471.     if (encoded.len > 0) {
    

  472.         free(encoded.data);
    

  473.         encoded.data = 0;
    

  474.     }
    

  475.     if (decoded.len > 0) {
    

  476.         free(decoded.data);
    

  477.         decoded.data = 0;
    

  478.     }
    

  479. }
    

  480.  
    

  481. int test_soft_des_ebc(void) {
    

  482.     const simple_des_key_t keys[] = {
    

  483.         {0x13, 0x34, 0x57, 0x79, 0x9B, 0xBC, 0xDF, 0xF1},
    

  484.         {0x0E, 0x32, 0x92, 0x32, 0xEA, 0x6D, 0x0D, 0x73},
    

  485.         {0x0E, 0x32, 0x92, 0x32, 0xEA, 0x6D, 0x0D, 0x73}
    

  486.     };
    

  487.     const ubyte message1[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF };
    

  488.     const ubyte message2[] = { 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87 };
    

  489.     const ubyte message3[] = { 0x59, 0x6F, 0x75, 0x72, 0x20, 0x6C, 0x69, 0x70, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x6D, 0x6F, 0x6F, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x76, 0x61, 0x73, 0x65, 0x6C, 0x69, 0x6E, 0x65, 0x0D, 0x0A };
    

  490.     int len;
    

  491.  
    

  492.     len = sizeof(message1) / sizeof(ubyte);
    

  493.     driver(keys[0], message1, len);
    

  494.  
    

  495.     len = sizeof(message2) / sizeof(ubyte);
    

  496.     driver(keys[1], message2, len);
    

  497.  
    

  498.     len = sizeof(message3) / sizeof(ubyte);
    

  499.     driver(keys[2], message3, len);
    

  500.     return 0;
    

  501. }
硬件实现的上述算法, 主要是从性能和编程的易用性考虑. 官方提供的Demo中没有商密系列的例子, 如果要使用这些算法的硬件加速单元, 可以和销售/技术支持联系.

还有上面的列表中说明支持TRNG
这个是真随机数发生器, 也是密码学算法中要使用的, 密码学中使用随机数, 既需要真随机也需要伪随机. 两者区别在于真随机数使用热噪音作为种子, 伪随机数使用特定的输入作为种子. 数学理论上没有真随机数, 类似于无法实现数学中的1/3分压,分频一样. 之所以称作TRNG, 是通过了一定的密码学测试标准, 国内/国际都有相应的测试标准.
复制
  1. uint32_t GetPseudoRand_U32(uint32_t *rand, uint32_t wordLen,uint32_t seed[2]);
    

  2. uint32_t GetTrueRand_U32(uint32_t *rand, uint32_t wordLen);
同学们可能会说C语言的库中也有随机数函数:
复制
  1. void srand(unsigned int _Seed);
    

  2. int rand(void);
为何不直接使用? 原因还是密码学标准, 不管国际还是国内的密码学标准, 都不会依赖某个libc的随机数实现. libC中的实现只能用于最简单的场景, 如模拟输入测试等等.


文末例子工程中hsm_test分支是硬件加速单元和几个软件算法实现的例子. 可供参考.

以后有闲暇会做软件/硬件 加密算法的benchmark. 本贴先到此为止.

例子代码下载地址点此






回复 赏

举报

相关帖子
6552918 发表于 2022-2-7 22:25 | 显示全部楼层
这块是国民的优势，应该好好发挥一下
回复 赏

举报

麻花油条 发表于 2022-2-8 11:04 来自手机 | 显示全部楼层
优势就应该好好发挥
回复 赏

举报

单片小菜 发表于 2022-2-8 16:28 | 显示全部楼层
加密算法都是通用的吧？
回复 赏

举报

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

本版积分规则

zhanzr21
个人签名：每天都進步

91

主题

1017

帖子

34

粉丝
快速回复 在线客服 返回列表 返回顶部
zhanzr21
个人签名：每天都進步

91

主题

1017

帖子

34

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