今天使用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 |
以上就是本次测试的所有内容，结果仅供参考。
