CF3310开发板是国产首创RISC-V安全微控制器，从官方资料可以了解到其所支持的安全功能：
其在硬件上，对加密功能进行了针对性的加强：
并在硬件级别提供了多种加密算法：
在经过学习官方资料包中提供的demo，以及经过官方技术人员手把手的指导，结合自己所了解的Python加密知识，实现了串口加密通信。
这篇分享中，演示的是从开发板发送经过加密处理的数据；
然后在上位机上，接收并解密对应的数据。
在开始之前，请先阅读我的上一篇分享 【CF3310开发板的串口使用】 ，了解串口的使用。
可以直接使用跳线帽，按照如图所示短接对应的引脚，这样Type-C口连接到电脑后，就能直接使用串口工具连接其对应的串口进行调试了：
然后，我选择的加密方式为AES_CBC：
先查看官方演示代码的src/demo/algo_demo.c中AES部分的代码，来了解加密解密的具体处理。
因为要使用AES_CBC加密，所以重点关注其中：aes.type = ALG_ECB、aes.KBits = ALG_KEY128部分的代码：
aes.mode = ALG_ENCRYPT;
aes.type = ALG_ECB;
aes.KBits = ALG_KEY128;
HAL_AES_SetSecurityLevel(&aes);
if(HAL_AES_Cryptographic(&aes,(uint8_t *)key,(uint8_t *)iv,(uint8_t *)plain,temp,32))
{
RETERR();
}
if(memcmp((uint8_t *)cipher_aes128_ecb,temp,32) != 0)
{
RETERR();
}
printf(" 通过
");
上述代码中，重点是加密函数：
uint8_t HAL_AES_Cryptographic(AES_ConfigTypeDef *hcfg,uint8_t *pKey,uint8_t *pIV,uint8_t *srcBuffer,uint8_t *destBuffer,uint32_t length)
官方提供的各种加密算法，都通过该函数进行调用，来获取加密后的结果。
其参数分别为：
最终，实际实现的代码如下：
/**
* [url=home.php?mod=space&uid=1455510]@file[/url] uart_sec.c
* [url=home.php?mod=space&uid=40524]@author[/url] HonestQiao
* [url=home.php?mod=space&uid=644434]@version[/url] V1.0
* @date 2022.6.28
* [url=home.php?mod=space&uid=2666770]@Brief[/url] uart sec test
*
*/
// eport
#include "eport_hal.h"
// uart
#include "uart_hal.h"
// algo
#include "algo_demo.h"
#include "algo_hal.h"
#include "trng_hal.h"
#include "cpm_hal.h"
#include "hal.h"
#include "delay.h"
#include "debug.h"
uint8_t uart_tx_buf[128];
uint8_t uart_rx_buf[128];
UART_HandleTypeDef UART_Handle;
int32_t counter = 0;
void AES_SEND_TEST(void)
{
AES_ConfigTypeDef aes;
uint8_t len = 0;
uint8_t loop = 0;
uint8_t key[32] = "1234567890654321"; // 加加密密钥
uint8_t iv[] = "9876543210123456"; // AES_ECB实际不用
uint8_t plain[32]; // 非存放明文
uint8_t temp[32]; // 临时存放加密后的结果
len = strlen(key);
memset(key + len, 0x00, 32 - len); // 将加密密钥用 0x00 填充到32位
memset(plain, 0x00, 32); // 明文清空
memset(temp, 0x00, 32); // 加密结果存放清空
counter++; // 计数器递增
if (counter > 999999) // 最大6位数
{
counter = 1;
}
sprintf(plain, "%06d", counter); // 将要被加密的明文信息
// printf("key=%s len=%d
", key, sizeof(key) / sizeof(key[0]));
// printf("plain=%s len=%d
", plain, sizeof(plain) / sizeof(plain[0]));
// 设置AES_ECB128加密
aes.level = dpa_disable;
aes.type = ALG_ECB;
aes.KBits = ALG_KEY128;
aes.mode = ALG_ENCRYPT;
HAL_AES_SetSecurityLevel(&aes);
// 加密处理
if (HAL_AES_Cryptographic(&aes, (uint8_t *)key, (uint8_t *)iv, (uint8_t *)plain, temp, 32))
{
memset(uart_tx_buf, 0x00, 256);
sprintf(uart_tx_buf, "ERROR:AES_256_ECB crypt error.
");
HAL_UART_Transmit(&UART_Handle,
uart_tx_buf,
sizeof(uart_tx_buf) / sizeof(uart_tx_buf[0]),
1000000);
return;
}
// 将加密结果转换为需要发送的ASCII字符串
memset(uart_tx_buf, 0x00, 256);
sprintf(uart_tx_buf, "DATA:%06d:", counter); // 测试阶段，将明文也发送过去
len = strlen(uart_tx_buf);
for (loop = 0; loop < 32; loop++)
{
uart_tx_buf[len + loop * 3 + 0] = "0123456789ABCDEF"[(temp[loop] >> 4) & 0x0F]; // 高位转换为ASCII字符
uart_tx_buf[len + loop * 3 + 1] = "0123456789ABCDEF"[temp[loop] & 0x0F]; // 低位转换为ASCII字符
uart_tx_buf[len + loop * 3 + 2] = ' '; // 空格
}
uart_tx_buf[len + loop * 3] = '
'; // 结尾
len = len + loop * 3 + 1; // 计算发送长度
// 通过串口发送数据
HAL_UART_Transmit(&UART_Handle,
uart_tx_buf,
len,
1000000);
}
// 串口初始化
void Bsp_UARTInit1(UART_HandleTypeDef *huart, UART_TypeDef *puart)
{
huart->Init.BaudRate = 115200;
huart->Init.IPSFreq = g_ips_clk;
huart->Init.Parity = UART_PARITY_MODE_NONE;
huart->Init.WordLength = UART_WORDLENGTH_8B;
huart->Instance = puart;
HAL_UART_Init(huart);
}
// 实际测试主体逻辑
void UART_CPU_SEC_RxTxTest(void)
{
// LED引脚设置
EPORT_InitTypeDef eport;
EPORT_PinDef pin_num;
EPORT_TypeDef *eport_base;
pin_num = EPORT_PIN4;
eport_base = EPORT;
eport.pin = pin_num;
eport.func = GPIO_FUN;
eport.dir = GPIO_DIR_OUT;
eport.output_mode = EPORT_OUTPUT_MODE_CMOS;
eport.pull_mode = EPORT_PULL_UP;
HAL_EPORT_Init(eport_base, &eport);
// algo设置
TRNG_HandleTypeDef htrng;
htrng.instance = TRNG;
htrng.dividor = 59;
HAL_CPM_ModuleClkCmd(MODULE_CLK_CRYPTO, ENABLE);
HAL_TRNG_Init(&htrng);
int8_t status = 0;
uint16_t loop = 0;
HAL_StatusTypeDef tmp_status;
/* init */
Bsp_UARTInit1((UART_HandleTypeDef *)(&UART_Handle), UART);
while (1)
{
HAL_UART_DisItTcie(&UART_Handle);
HAL_UART_DisItTie(&UART_Handle);
HAL_UART_DisItRe(&UART_Handle);
while (1)
{
// 让LED交替闪亮，以示程序正在运行
HAL_EPORT_TogglePin(eport_base, pin_num);
if (!status)
{
HAL_EPORT_WritePin(eport_base, pin_num, BIT_RESET);
}
else
{
HAL_EPORT_WritePin(eport_base, pin_num, BIT_SET);
}
status = !status;
// AES串口加密数据发送测试
AES_SEND_TEST();
DelayMS(1000);
}
}
}
// 测试入口函数
void UART_SEC_Run(void)
{
UART_CPU_SEC_RxTxTest();
}
将上述代码覆盖掉src/demo/uart_demo.c，然后在src/inc/demo.h中开启UART，就能编译下载了。
以上的代码，整合了EPORT控制PIN4，UART数据发送，以及ALGO加密算法，每1秒钟发送一次数据。
所以实际的连线如下：
代码中，使用的：
DATA:6位明文:密文HEX的ASCII码发送的数据中，带有明文的目的，是为了方便上位机测试验证。
将开发板使用Type-C连接到电脑，在上位机中，使用串口工具监听串口，然后编译下载运行以上代码，就可以收到如下串口信息了：
在DATA:6位明文:后面的部分，就是6为明文加密后对应的HEX值，我们获取该值，然后使用AES_ECB进行解密，就能还原得到明文了。
解密的部分，我使用Python来实现的。
首先，需要安装pycrypt：
pip3 install pycryptodomepip install pycrypto然后，使用如下的代码：
import serial
import serial.tools.list_ports
import hashlib
import base64
from Crypto.Cipher import AES
from Crypto.Cipher import DES
from Crypto.Util.Padding import pad, unpad
password = b''
class Communication():
#初始化
def __init__(self,com,bps,timeout):
self.port = com
self.bps = bps
self.timeout =timeout
global Ret
try:
# 打开串口，并得到串口对象
self.main_engine= serial.Serial(self.port,self.bps,timeout=self.timeout)
# 判断是否打开成功
if (self.main_engine.is_open):
Ret = True
except Exception as e:
print("---异常---：", e)
#打开串口
def Open_Engine(self):
self.main_engine.open()
#关闭串口
def Close_Engine(self):
self.main_engine.close()
print(self.main_engine.is_open) # 检验串口是否打开
# 打印可用串口列表
@staticmethod
def Print_Used_Com():
port_list = list(serial.tools.list_ports.comports())
print(port_list)
def Read_Size(self,size):
return self.main_engine.read(size=size)
#接收一行数据
# 使用readline()时应该注意：打开串口时应该指定超时，否则如果串口没有收到新行，则会一直等待。
# 如果没有超时，readline会报异常。
def Read_Line(self):
return self.main_engine.readline()
#发数据
def Send_data(self,data):
self.main_engine.write(data)
def Recive_data(self,way):
# 循环接收数据，此为死循环，可用线程实现
print("开始接收数据：")
data = b''
while True:
try:
# 一个字节一个字节的接收
if self.main_engine.in_waiting:
if(way == 0):
for i in range(self.main_engine.in_waiting):
print("接收ascii数据："+str(self.Read_Size(1)))
data1 = self.Read_Size(1).hex()#转为十六进制
data2 = int(data1,16)#转为十进制
print("收到数据十六进制："+data1+" 收到数据十进制："+str(data2))
if(way == 1):
#整体接收
# data = self.main_engine.read(
# self.main_engine.in_waiting).decode("utf-8")#方式一
tmp = self.main_engine.read_all()#方式二
print("接收ascii数据：", tmp)
data = data + tmp
if tmp[-1] == 10:
data_hex = bytes.fromhex(data[12:-2].decode())
data_plain = data[5:11].decode()
print(" 接收到一批数据：", data[12:-2])
print(" 接收到的明文数据：", data_plain)
date_de = decrypt(data_hex, password)
data_de_plain = date_de.decode()
print(" 解码后的明文数据：", data_de_plain)
data = b''
except Exception as e:
print("异常报错：",e)
def encrypt(data, password):
bs = AES.block_size
pad = lambda s: s.ljust(bs,b'')
cipher = AES.new(password, AES.MODE_ECB)
data_used = pad(data)
print("pad(data):", len(data_used), data_used)
data = cipher.encrypt(data_used)
return (data)
def decrypt(data, password):
bs = AES.block_size
if len(data) < bs:
print("direct return",data,len(data),bs)
return (data)
cipher = AES.new(password, AES.MODE_ECB)
data = cipher.decrypt(data)
return (data)
if __name__=="__main__":
AES.block_size = 32
password = b'1234567890654321' #16,24,32位长的密码
com = Communication("/dev/cu.usbserial-14240", 115200, None)
com.Print_Name()
plain,denc_hex = com.Recive_data(1)
将以上代码，保存为：uart_sec_recv.py，准备执行。执行以前，要先关掉串口监听工具。
使用python uart_sec_recv.py执行，开始监听串口，就能接收到串口数据，并进行解码：
从上述结果中可以看到，解码后的数据，与传送过来的明文数据，是一致的，因此加密发送并解码成功。
以上的分享，演示的是开发板发送加密数据，使用了AES_ECB128加密算法，参考algo_demo.c，可以试用其他的加密算法，当然，上位机的代码也需要进行针对性的处理。
乔帮主微五。。
举报
更多回帖
