STM32Cube系列教程11：STM32 AES加解密模块性能测试

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

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

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

本次测试环境

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

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

AES算法与数据加解密

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

加密与解密

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

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

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

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

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

对称加解密

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

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

通常用于对大量数据进行加密，
常用的加密算法：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){// *****************

测试结果

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

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