【NUCLEO-U083RC评测】+ AES加解密模块性能测试

[复制链接]

Joseph_chn 发布时间：2024-6-10 12:18

文章
文章封面:
文章简介:	今天使用NUCLEO-U083RC的评估板，测试一下他内置的AES加速模块性能如何。本次测试所使用的系统时钟为48MHz 本次测试主要测试对大量数据进行加解密所需的时间，本次为不严谨测试，忽略了程序调用耗时，结果仅供参考。

今天使用NUCLEO-U083RC的评估板，测试一下他内置的AES加速模块性能如何。

全部代码以上传到github：https://github.com/what-sudo/stm32U083

本贴同步发表到本人CSDN账号：文章地址：STM32Cube系列教程11：STM32 AES加解密模块性能测试-CSDN博客

正文开始，本工程基于前期配置的工程模板，感兴趣的可查看之前的文章。《STM32Cube系列教程10：STM32CubeIDE工程创建+串口DMA+IDLE+printf重定向+软中断处理串口数据+非阻塞延时任务》

本次测试环境

本次测试所使用的系统时钟为48MHz

本次测试主要测试对大量数据进行加解密所需的时间，本次为不严谨测试，忽略了程序调用耗时，结果仅供参考。

AES算法与数据加解密

在使用aes模块之前，这里先简单说一下什么是加解密以及aes算法的特性以下内容摘录自我的另一篇文章，其中简单讲述了对称加密算法，非对称加密算法，数据散列算法等内容，感兴趣的请移步观看。《数据安全-签名、加密、与填充》

加密与解密

加密：将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文。解密：使用密钥及对应的解密算法对密文进行解密，使其恢复成可读明文。

加解密通常需要使明文数据按照一定长度对齐，叫做块大小（BlockSize），例如AES加解密的BlockSize为16字节，RSA加解密的BlockSize等于密钥长度。

如果数据长度无法对齐到要求的长度，就需要使用填充算法，加密前与解密后需要使用相同的填充算法对数据进行填充或解填充。

加密与解密一般需要对数据进行分包，将明文数据分包处理后，使用加密算法对每包数据进行运算，求出密文数据，每包密文数据的长度通常都是等长的，将每包密文依次连接，形成完整的密文数据。

解密时，按照加解密算法对应的包长度，依次将每包密文进行解密运算，拼凑出明文数据。

对称加解密

加密密钥与解密密钥相同的加密算法。特点：

算法公开
计算量小
速度快，效率高
密钥传输与密钥管理麻烦

通常用于对大量数据进行加密，常用的加密算法：AES、DES。

AES算法

AES算法安全性与密钥长度关联，密钥长度越长，越安全。 AES密钥分为AES128、AES192、AES256。明文需要被分为固定长度的块进行加密，BlockSize为16字节。数据如果被损坏，解密能正常运算，但会得到错误的明文。 AES算法通常分为ECB与CBC模式，我们通常使用的时CBC模式。

AES-ECB

ECB模式是最简单的AES加密模式
使用一个固定长度的密钥
固定的明文将会生成固定的密文，如果有两个相同的明文块，则加密结果也相同。

优点简单，有利于并行计算，误差不会传递。

缺点安全性低，容易被爆破

加密流程 解密流程

AES-CBC

加解密需要使用一个固定长度的密钥
加解密需要一个16字节的初始向量
相同的明文不会生成相同的密文

优点

安全性比ECB好

缺点

不利于并行计算，误差会被传递，需要保存初始向量IV

加密流程 解密流程

填充算法

AES加解密算法仅支持按照block大小进行加解密，如果需要加密的数据无法被block大小整除，则无法加密，因此这里需要对原始数据进行填充，aes加密算法使用的填充方法为PKCS7Padding算法，这也是openssl库中，对aes加解密时默认使用的填充算法，我们需要保证我们加密出的数据能够与openssl互通，因此需要以openssl为标准，（openssl是一个开源的软件库，程序可以使用这个库进行安全通信，数据加解密等操作，详情请自行百度）。在进行加密操作之前。需要对原始数据进行填充，在密文解密为明文后，需要按照填充规则，对解密数据进行解填充，才能获取到真实的原始数据。

内容摘录自我的另一篇文章，其中简单讲述了对称加密算法，非对称加密算法，数据散列算法等内容，感兴趣的请移步观看。《数据安全-签名、加密、与填充》

PKCS7Padding

PKCS7是16字节填充的，即填充一定数量的内容，使得成为16的整数倍，而填充的内容取决于需要填充的数目。例如：

// 原数组
{0x56}
//PKCS7填充结果
{0x56, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f}

// 原数组
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}
//PKCS7填充结果
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08}

// 原数组
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}
//PKCS7填充结果
{
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10
}

如果已经满足了16的整倍数，按照PKCS7的规则，仍然需要在尾部填充16个字节，并且内容是0x10,目的是为了加解密时统一处理填充。 因此进行pkcs7填充后的数据，最多会比原始数据长16个字节 原理讲到这里，下面我们写代码测试一下。

配置硬件AES模块初始化

打开我们的工程模板，在CubeMX配置中，打开Security --> AES配置，勾选Activated功能，注意Data type设置是否为默认值32b，Data width unit与Header width unit需要保持为word类型，其他配置保持默认即可，我这里曾改为CBC模式，系统默认应该时ECB模式，这里无影响，后面我会在代码中重新配置加解密模式与密钥key。保存并生成代码。

编写测试代码

这里我们主要使用ECB与CBC两种模式，进行多轮加解密，通过计算加解密的时间，来衡量aes模块的性能。

编写填充与解填充代码

通过这两个函数，在加密前与解密后，对数据进行填充与解填充。

/**
 * @brief  pkcs7填充算法
 * @param  p: 需要填充的数据指针
 * @param  len: 需要填充的数据长度
 * @param  block_size: 按照多大的block进行填充，通常为16
 * @return 填充后的数据长度
 * @author joseph
 * @date   2024.5.27
 */
static size_t pkcs7Padding(unsigned char *p, size_t len, uint8_t block_size)
{
    uint8_t i = 0;
    uint8_t padding = 0;
    padding = block_size - len%block_size;

    for (i = 0; i < padding; i++) {
        p[len + i] = padding;
    }

    return (len + padding);
}

/**
 * @brief  pkcs7解填充算法
 * @param  p: 需要解填充的数据指针
 * @param  len: 需要解填充的数据长度
 * @param  block_size: 按照多大的block进行填充，通常为16
 * @return 解填充后的数据长度
 * @author joseph
 * @date   2024.5.27
 */
static size_t pkcs7UnPadding(unsigned char *p, size_t len, uint8_t block_size)
{
    uint8_t unPadding  = 0;
    unPadding  = p[len - 1];
    int i = 0;

    if (unPadding > 16) {
        return -1;
    }

    for (i = 0; i < unPadding; i++) {
        if (p[len - 1 - i] != unPadding)
            return -1;
    }

    return (len - unPadding);
}

编写大小端转换代码

STM32中数据的保存方式为小端模式，但是在openssl中，默认使用的是大端模式，为了保证在使用相同的输入时，能够获取到相同的输出，因此需要进行大小端转换。

#define BLSWAP32(val) \
    ((val) = ((uint32_t)((((uint32_t)(val) & (uint32_t)0x000000ffU) << 24) | \
          (((uint32_t)(val) & (uint32_t)0x0000ff00U) <<  8) | \
          (((uint32_t)(val) & (uint32_t)0x00ff0000U) >>  8) | \
          (((uint32_t)(val) & (uint32_t)0xff000000U) >> 24))))

编写aes模块密钥与模式配置代码

通过这个函数对aes模块进行密钥与算法模式进行配置

typedef enum {
  AES_ALGO_ECB,
  AES_ALGO_CBC,
} AES_Algorithm_t;

/**
 * @brief  aes模块密钥与模式配置代码
 * @param  key: aes密钥指针
 * @param  key_len: aes密钥长度
 * @param  mode: aes算法模式，ECB/CBC
 * @param  iv: 初始向量指针，如果为ECB时，入参NULL即可
 * @return 0：SUCCESS, <0: fail
 * @author joseph
 * @date   2024.5.27
 */
int aes_set_config(uint8_t *key, int key_len, AES_Algorithm_t mode, uint8_t *iv)
{
  int ret = -1;
  CRYP_ConfigTypeDef cryp_conf = {0};
  do {
    if (key_len != 32 || key == NULL) {
      printf("error: The key length only supports 32\n");
      break;
    }

    if (mode == CRYP_AES_CBC && iv == NULL) {
      printf("error: iv param is null\n");
      break;
    }

    for (int i = 0; i < key_len >> 2; i ++)
        BLSWAP32(((uint32_t*)key)[i]);

    if (HAL_CRYP_GetConfig(&hcryp, &cryp_conf) != HAL_OK) {
      printf("error: HAL_CRYP_GetConfig fail\n");
      break;
    }
    cryp_conf.Algorithm = (mode == AES_ALGO_ECB) ? CRYP_AES_ECB : CRYP_AES_CBC;
    cryp_conf.pKey = (uint32_t *)key;

    if (mode == AES_ALGO_CBC) {
      for (int i = 0; i < 4; i ++)
          BLSWAP32(((uint32_t*)iv)[i]);
      cryp_conf.pInitVect = (uint32_t *)iv;
    }

    if (HAL_CRYP_SetConfig(&hcryp, &cryp_conf) != HAL_OK) {
      printf("error: HAL_CRYP_SetConfig fail\n");
      break;
    }
    ret = 0;
  } while (0);
  return ret;
}

封装加解密接口

通过封装的这个接口，完成对数据的加密与解密 ##### 注意：代码中的CRYPT_NUM_TIMES 时我进行多轮测试时使用的，正常进行加解密时，应该删除与CRYPT_NUM_TIMES有关的代码，或将CRYPT_NUM_TIMES设置为1。#####


typedef enum {
  AES_ENCRYPTO_MODE,
  AES_DECRYPTO_MODE,
} AES_Crypt_Mode_t;


#define CRYPT_NUM_TIMES 1   // 设置加解密测试轮数

/**
 * @brief  aes加解密接口
 * @param  mode: aes加解密模式，EN/DE
 * @param  in_buffer: 等待加解密的数据指针
 * @param  inlen: 输入的数据长度
 * @param  out_buffer: 保存加解密后数据的内存指针
 * @return 0：输出的数据长度, <0: fail
 * @author joseph
 * @date   2024.5.27
 */
int aes_crypt(AES_Crypt_Mode_t mode, unsigned char *in_buffer, int inlen, unsigned char *out_buffer)
{
  int ret = -1;
  int plain_len = 0;

  memmove(tmp_buffer, in_buffer, inlen);

  do
  {

    start = HAL_GetTick();
    for (i = 0; i < CRYPT_NUM_TIMES; i++)
    {
      memmove(in_buffer, tmp_buffer, inlen);

      if (mode == AES_ENCRYPTO_MODE) {
        plain_len = pkcs7Padding((uint8_t *)in_buffer, inlen, AES_BLOCK_SIZE);
        for (int i = 0; i < plain_len >> 2; i++)
          BLSWAP32(((uint32_t *)in_buffer)[i]);

        if (HAL_CRYP_Encrypt(&hcryp, (uint32_t *)in_buffer, plain_len >> 2, (uint32_t *)out_buffer, 0xff) != HAL_OK)
        {
          printf("error: HAL_CRYP_Encrypt fail\n");
          break;
        }

        for (int i = 0; i < plain_len >> 2; i++)
          BLSWAP32(((uint32_t *)out_buffer)[i]);
      } else {
        for (int i = 0; i < inlen >> 2; i++)
          BLSWAP32(((uint32_t *)in_buffer)[i]);
        if (HAL_CRYP_Decrypt(&hcryp, (uint32_t *)in_buffer, inlen >> 2, (uint32_t *)out_buffer, 0xff) != HAL_OK)
        {
          printf("error: HAL_CRYP_Decrypt fail\n");
          break;
        }

        for (int i = 0; i < inlen >> 2; i++)
          BLSWAP32(((uint32_t *)out_buffer)[i]);

        plain_len = pkcs7UnPadding((uint8_t*)out_buffer, inlen, AES_BLOCK_SIZE);
      }

    }
    end = HAL_GetTick();
    if (i != CRYPT_NUM_TIMES) {
      printf("[%d] error: CRYPT_NUM_TIMES i:%d fail\n", __LINE__, i);
      break;
    }

    interval = end - start;
    printf("%s %d times: %ld\n", mode == 0 ? "encrypto" : "decrypto", CRYPT_NUM_TIMES, interval);

    ret = plain_len;
  } while (0);

  return ret;
}

编写ecb测试代码


int aes_ecb_test(void)
{
  int ret = -1;
  int text_len = strlen(Text);
  int length = 0;

  do {
    memmove(AES_key, AES_key1, 32);
    aes_set_config(AES_key, 32, AES_ALGO_ECB, NULL);

    printf("==== aes_ecb_test 1 ==== \n");
    memset(plain, 0, sizeof(plain));
    memmove(plain, Text, text_len);

    length = aes_crypt(AES_ENCRYPTO_MODE, plain, text_len, cipher);
    if (length < 0) {
      printf("[%d] error: aes_crypt fail\n", __LINE__);
      break;
    }

    printf("encrypto len: %d\n", length);
    // show_hex(cipher, 64);

    memset(plain, 0, sizeof(plain));

    length = aes_crypt(AES_DECRYPTO_MODE, cipher, length, plain);
    if (length < 0) {
      printf("[%d] error: aes_crypt fail\n", __LINE__);
      break;
    }

    printf("decrypto len: %d\n", length);
    // printf("%.*s\n", 64, plain);

    if (text_len == length && memcmp(plain, Text, length) == 0) {
      printf("\naes_ecb_test success\n");
    } else {
      printf("\naes_ecb_test fail\n");
    }

    ret = 0;
  } while (0);

  return ret;
}

编写cbc测试代码


int aes_cbc_test(void)
{
  int ret = -1;
  int text_len = strlen(Text);
  uint16_t length = 0;

  do {
    memmove(AES_key, AES_key1, 32);
    memmove(aesiv, aesiv1, 16);
    aes_set_config(AES_key, 32, AES_ALGO_CBC, aesiv);

    printf("==== aes_cbc_test 1 ==== \n");
    memset(plain, 0, sizeof(plain));
    memmove(plain, Text, text_len);

    length = aes_crypt(AES_ENCRYPTO_MODE, plain, text_len, cipher);
    if (length < 0) {
      printf("[%d] error: aes_crypt fail\n", __LINE__);
      break;
    }

    printf("encrypto len: %d\n", length);
    // show_hex(cipher, 64);

    memset(plain, 0, sizeof(plain));

    length = aes_crypt(AES_DECRYPTO_MODE, cipher, length, plain);
    if (length < 0) {
      printf("[%d] error: aes_crypt fail\n", __LINE__);
      break;
    }

    printf("decrypto len: %d\n", length);
    // printf("%.*s\n", 64, plain);

    if (text_len == length && memcmp(plain, Text, length) == 0) {
      printf("\naes_cbc_test success\n");
    } else {
      printf("\naes_cbc_test fail\n");
    }

    ret = 0;
  } while (0);

  return ret;
}

创建密钥与待加密的数据

以下这些变量是在程序执行过程中需要使用的数据，其中明文数据约3.5k字符，用于测试加解密性能。


// 加解密的key
uint8_t AES_key1[33] = "12345678901234561234567890123456";
// cbc模式下需要使用的初始向量iv
uint8_t aesiv1[17] = "1234567890123456";

// 多轮加密时，需要传入的密钥内存
uint8_t AES_key[32] = {0};
uint8_t aesiv[16] = {0};

// 待加密的原始数据，约3.5K字符。
char Text1[] = " \
-----BEGIN PRIVATE KEY-----                                      \
MIIJQQIBADANBgkqhkiG9w0BAQEFAASCCSswggknAgEAAoICAQCsXDZ8s9ToFi+t \
+HE9KfJSPOYjGR/OxnAUNPxKWoQ6l5nCS9Uhazdl9hF6PDjy0mGE6ZFdW7c+Tsmg \
uTIMVY0BlOT6hRwfxoSLqjF6L99Nb906cOX5eGxEbOE0k9OFkKZw3KGiPpm007TN \
3IBwYRLoVLwnXHFfcsJ4w52GfwOyFAlc99Nv45/o4lzj3yYdBWBey1bLotoTcK1u \
J97iv6DFTb28GN/XR3qbSHNFJsxKtwoj8Rwj3aAq/4cVpH7uhkOOLjCclBdsWTlb \
fmuZJ4ISfHnMDtZjIEH3LAb8ILoGnytcqTd9nb4d0gYsKFsqAjrK4akDq85ZQQx7 \
At4jzY5+C0lwM89WxP0/saph6lsgdhjjS9P8I7dwJyFTaLfiaKIOYf31w9mHrpnS \
yIRGg+Enw+osow6cQ49m6klCnvs46bJ9ZaSg1wqKkrp8VSvBs1tto749NS5YcTKT \
+oQwpqHWpbrEr78oTCYRrf/8ggk0LHP/PRj6GNJYMX62BafInz6RnwWUb6n+BoF8 \
ioXZ17aa0mBAx+REfjwxk1S+5EblhU1a92V5x1YwVUTfnN19FVmXJpv/o3nx6cwk \
c8j0xMRMNPHVJIOGNcgYmlzpRGMC6DYP69Cj64k9uLmESVCRuyQzJjZbANqDNvFa \
0cjpbKkRDOtzxzjjivawPc6okW7W7QIDAQABAoICAADp3aKjI/D1ikmVRE4Y5nYc \
aPL/Y3MgnbJ1uJO+4cmI23PYHAzdgkFx4KaNInK1UFJKzunJ+bpyUJmx+ruSboJA \
bEcggDMEWCFb8n+dgcT78d8pEVAeiqKl7DrLChKcFeAJsQsNUJo+Zd624mes73gT \
oS7P8Gfkdi2Niif8jRGtfMuAtQyKjhmiiO/u0zT2Bx6pgNANWdgerSAS10+n7Vtu \
W2kEBrxETDhrej4SOsllKa3PhI6X0nrcbyQSS+mllvWlLJl/2yej7kgcE8hY9J3k \
UtynFp9gl5szIS6iNOo0f5+NUcQwLX1tZp5ClVrUAKAzFdkHoii18lZYSVT79kkD \
yN66XwwrIRUeZkRAy+gI2IxtsA1T0rexN/bRV/ZRLyW5GVlMnd4z7h8OGj+WcMjh \
PCniGxu03wp2rulRSYPs0/krZ3+mKYNtzkv/2fKJZKlqA8qvsFKWxcODMHtFoglf \
ea6rHoCRckRzIB30I8ro7b+XXZN3B9hgHQuXtwEUq6jnnF9l9x+eEQC/qf2wtxAK \
EO3Dd/fRUbbPEr8gvRBNdbEEQRxMCaKBGHmqu+5RELhsnrgGKmHnbricxouVIS54 \
1MS1DakaqZRJkz//5IYR6lP08kDGqWIbCo5B9vlrJtg3iwHf86W8anBHMZC1PtcC \
lh1anrVvt3V4pr2T3xrPAoIBAQDqyOGddJL7Rx5Wd2RuIXA+8WmIFqBzwsRyS9oN \
Ns1IP9etANzt5Tmhs5yxb7RsI5olwOVtdgVpieUPRkUgrmt1bkSxRPKtZ7k753aV \
rgqNaaOrZGEYwW7jC5xPmQAkqJthhIgTWjJh7N5Sby5nvLsSD4dhp6AfGBN6kEzs \
KH9IlDdO+fuCPgCBGEZnkKIuOM/NFRO/VEJpGRuaGqPMZhbmDKkilP3yfSezqDuT \
3Put+0XsfPzucozDfe/07O99Fwi/zQyI5Wz5ZSICnmkXH7HDbb4jH/VP8rO6HhCf \
z48Hlk3xAY9aD13PSmaJauqwpu2RPsvkse1ZdhZDKeyfiKF7AoIBAQC7706o1us+ \
p+RbY5JqruO5b3+yb0c/sGHX77c/qSFWQ1QOy9iVtmzWR9+yajzUqa5zwIm1awit \
/PFlw444ClESAV4Qy47TwwU4SIGBn2+5g0bQI2/x/TYG+EYxKUiIlvGcZlnrz6/H \
z60y0usTzNTNDKVcjnt7lBEM2XcEGwxNbwWfRzwHGGLFOurJmuKZF1JE9js3nLHN \
QbwPI1JGAnfMKTvLWa9CV3Mq6xhTazoTe1S2ubnG/wa9getgrziiqKlPshmmjzCi \
YK8YiFRF72E+mY/bl5DSiN2X/ltuepGjTe0iZ9Bd64puhmI1Nyoy1vEAME5Fw7je \
CTpaFgKCKbi3AoIBACLpResU13o3xAIVdMCPhlJFsWyD+M3dyzo3ny/R00qH+7kE \
5NUW/a/WtlkIBCsETDqK6VKSdxGPaJkR2NuYM/BdOiel2fQA9WE79L0jCPyoFac5 \
oNp+gM+P/Wk0lfndfGVOwLEn+0/mWdSmJZ9VR/fSiU3zD/MvsE3MQTPofay8JVFA \
CK8AKzEG/AkQT51R40xacvpDPDDGg/0xMuQE1ijU/x1eTDiPdaTYQiulc2MWdvpI \
R4/pRpcXFeQ0ixPtpeZnRhLhEogvCpSbG4NNujAWFGzCpsaBj0oAiHZK9biqF+Lb \
WYaJvGhDZuXOGSG1YKP1U3opHuLrlTnddQrv1RsCggEAKsU8rpoy8ZB+HPpdQSBK \
PVKNykse+PSoX99zYe6Y4qvx/mgQA4p/3IiA9XbOH0v6oudHr90LHaW6PoGx5Tkb \
2DAtez8IY1M35eZCawChCaRBwm6+NGF/ITjxqJCPrF5F4GU+w7cBd0ThUvbDfz8X \
kw70t0rJ+YbqFnWLa4jIVPsWWXh5xdeb6u0MsBMqzNKM65rqQS7NHDyAkyVjvQEk \
yHb937qqczu5vyO/5oQ5tGNWFTvRduNlYk2mBtv51LLzzWpoAgsGc33ze27TVxMy \
m2+RWNV2pSN24veFUXBdor/CXxknR6iqWZsF0LycQvO952AXADOZ6BZLjGMD8SGT \
owKCAQBSY8O/L6/vtICdfyX24S1FTxrQdQVCk03a3LcRnO9Loaxuvawy6lcjicDE \
YAP51EYhOKW9akxBRSEB2soRs92rnuBS522re6k/c8GUc+k3tkj5Go8v8Dqg+biW \
D5Zu2x0rXJ/caO6u0le6UrI+IOScuIPJ6tuu9OhV9sr5zJzAfIUupRpckD6TP7/X \
T6fG4lNteg8ftRfRvYd6g/jEmh/ECHvc5YDdXihDGv028BFj5fWY/iZEjMGektRf \
tPyMMOI4+t93oni0Go8OkF2FIYsquWMEh4IILMm27mVZk7A+FLW+hK/FXec3dogO \
7IbiS/98RTtjVN4NIQJ9Jc8hUhkW                                     \
-----END PRIVATE KEY-----                                        \
";

char *Text = Text1;

// 加解密过程中，需要的内存
uint8_t plain[4096 + 16] = {0};
uint8_t cipher[4096 + 16] = {0};
uint8_t tmp_buffer[4096 + 16] = {0};

// 计算加解密时间所需要的变量
int i = 0;
uint32_t start, end, interval;

调用测试接口对aes模块进行测试

到这里，测试需要的代码已经全部编写完成，只需要在while循环之前调用对应的测试接口，就可以完成对aes模块的性能测试

** 注意：需要修改上文曾提到的宏CRYPT_NUM_TIMES，通过修改这个宏的值，来设置加密的轮数。这里我已经将其设置为1000

// 分别测试ecb与cbc加密
  aes_ecb_test();
  aes_cbc_test();

  while (1)
  {
    // *****************

测试结果

编译代码，查看是否有编译报错，编译成功后，将代码烧录到单片机，通过串口调试工具，可查看到结果。数据显示：

加密模式	单次计算字节	计算轮数	总计算字节	所用时间(ms)	每KB耗时(ms)
ECB加密	3392	1000	3312.5KB	6061	1.83
ECB解密	3381	1000	3301.8KB	6039	1.83
CBC加密	3392	1000	3312.5KB	6063	1.83
CBC解密	3381	1000	3301.8KB	6041	1.83

以上就是本次测试的所有内容，结果仅供参考。

赞收藏评论0 发布时间：2024-6-10 12:18

0个回答

所属标签

STM32U0