stm32F4 AES256加解密

已于 2022-11-01 00:19:14 修改
阅读量1.2k 收藏 3
点赞数 1
分类专栏： FreeRTOS STM32 单片机外围电路 文章标签： stm32 单片机 arm
于 2022-10-31 23:41:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dmjkun/article/details/127625690
版权
高级MCU带有AES加密引擎，硬件加密可使数据发出后马上返回结果，软件加密库可参考mbedTLS。信息安全重要，通讯和存储数据常加密。还给出了读写函数示例，对上层或应用友好。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

现在高级点的MCU都会带AES加密引擎，软件算有延迟硬件基本可以数据发出结果就马上返回，软件加密库可参考mbedTLS，现在信息安全也是很重要通讯数据，存储数据都会进行加密存储以防被破解防制，我写程序的习惯都是对于上层或应用来说都是很友好，crypt_read(CARD_MANAGE_TypeDef *card_manage,uint16_t addr, uint16_t len, uint8_t *ptr)、crypt_write(CARD_MANAGE_TypeDef *card_manage,uint16_t addr, uint16_t len, uint8_t *ptr) 读写2个函数

#include "system.h"
#include "crypt.h"
#include "at88sc.h"
#include "smartcard.h"
//#include "aes.h"
#include "secure_storage.h"
#include "string.h"
//#include "aes.h"
#include "stm32f4xx_hal.h"

#undef CRYPT_DEBUG
#ifdef CRYPT_DEBUG
    #define	crypt_log(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[CRYPT](%ld) ",__LINE__);DBG_LOG(__VA_ARGS__);}}while(0)
    #define crypt_usr(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[CRYPT] ");DBG_USR(__VA_ARGS__);}}while(0)
    #define crypt_err(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[CRYPT] ");DBG_ERR(__VA_ARGS__);}}while(0)
    #define crypt_dump(...) if(DEBUG(DEBUG_ENABLE)){DBG_DUMP(__VA_ARGS__);}
#else
    #define crypt_log(...)
    #define crypt_usr(...)
    #define crypt_err(...)
    #define crypt_dump(...)
#endif

CRYP_InitTypeDef init;

CRYP_HandleTypeDef hcryp;
DMA_HandleTypeDef hdma_cryp_in;
DMA_HandleTypeDef hdma_cryp_out;

xSemaphoreHandle	crypt_semaphore;
uint8_t crypt_complete=0;
extern void Error_Handler(SYSTEM_ERROR_CODE_TypeDef errorCode);

/**
* @brief CRYP MSP Initialization
* This function configures the hardware resources used in this example
* @param hcryp: CRYP handle pointer
* @retval None
*/
void HAL_CRYP_MspInit(CRYP_HandleTypeDef* hcryp)
{

  if(hcryp->Instance==CRYP)
  {
  /* USER CODE BEGIN CRYP_MspInit 0 */

  /* USER CODE END CRYP_MspInit 0 */
    /* Peripheral clock enable */
    __HAL_RCC_CRYP_CLK_ENABLE();
    /* CRYP interrupt Init */
    HAL_NVIC_SetPriority(CRYP_IRQn, 14, 0);
    HAL_NVIC_EnableIRQ(CRYP_IRQn);
  /* USER CODE BEGIN CRYP_MspInit 1 */

  /* USER CODE END CRYP_MspInit 1 */
  }

}

/**
* @brief CRYP MSP De-Initialization
* This function freeze the hardware resources used in this example
* @param hcryp: CRYP handle pointer
* @retval None
*/

void HAL_CRYP_MspDeInit(CRYP_HandleTypeDef* hcryp)
{

  if(hcryp->Instance==CRYP)
  {
  /* USER CODE BEGIN CRYP_MspDeInit 0 */

  /* USER CODE END CRYP_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_CRYP_CLK_DISABLE();

    /* CRYP interrupt DeInit */
    HAL_NVIC_DisableIRQ(CRYP_IRQn);
  /* USER CODE BEGIN CRYP_MspDeInit 1 */

  /* USER CODE END CRYP_MspDeInit 1 */
  }

}

static void MX_CRYP_Init(uint8_t *key)
{

  /* USER CODE BEGIN CRYP_Init 0 */

  /* USER CODE END CRYP_Init 0 */

  /* USER CODE BEGIN CRYP_Init 1 */
	
  /* USER CODE END CRYP_Init 1 */
  hcryp.Instance = CRYP;
  hcryp.Init.DataType = CRYP_DATATYPE_8B;
  hcryp.Init.KeySize = CRYP_KEYSIZE_256B;
  hcryp.Init.pKey = (uint8_t *)key;
  if (HAL_CRYP_Init(&hcryp) != HAL_OK)
  {
//    Error_Handler();
  }
  /* USER CODE BEGIN CRYP_Init 2 */

  /* USER CODE END CRYP_Init 2 */

}

/** 
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void) 
{
  /* DMA controller clock enable */
  __HAL_RCC_DMA2_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA2_Stream5_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 14, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn);
  /* DMA2_Stream6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 14, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);

}

/**
  * @brief This function handles CRYP global interrupt.
  */
void CRYP_IRQHandler(void)
{
  /* USER CODE BEGIN CRYP_IRQn 0 */

  /* USER CODE END CRYP_IRQn 0 */
  HAL_CRYP_IRQHandler(&hcryp);
  /* USER CODE BEGIN CRYP_IRQn 1 */

  /* USER CODE END CRYP_IRQn 1 */
}

/** 
* AES256执行完成回调. 
* 设置标志位，加解密函数等待这个标志位. 
* @param[in]   hcryp:AES256句柄. 
* @param[out]  无.  
* @retval  无
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      Kend Deng于2019-03-29创建 
*/
void HAL_CRYP_OutCpltCallback(CRYP_HandleTypeDef *hcryp){
	crypt_complete = 1;
}

/** 
* AES256加密函数. 
* 判断是不16字节倍数，启动硬件加密并等待结果. 
* @param[in]   key:秘钥，in:输入明文数据，out:输出密文数据，size:长度，必需16的倍数. 
* @param[out]  无.  
* @retval  无
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      Kend Deng于2019-03-29创建 
*/
void crypt_encryption(uint8_t *key, uint8_t *in, uint8_t *out, uint16_t size){
	
	if( size % 16 == 0 && size!=0 ){
		MX_CRYP_Init(key);
//		__HAL_CRYP_RESET_HANDLE_STATE(&hcryp);
		crypt_complete = 0;
		HAL_CRYP_AESECB_Encrypt_IT(&hcryp, in, size, out);
		while(crypt_complete==0){
			vTaskDelay(1);
		}
//		xSemaphoreTake(crypt_semaphore,1000);
	}
}

/** 
* AES256解密函数. 
* 判断是不16字节倍数，启动硬件解密并等待结果. 
* @param[in]   key:秘钥，in:输入明文数据，out:输出密文数据，size:长度，必需16的倍数. 
* @param[out]  无.  
* @retval  无
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      Kend Deng于2019-03-29创建 
*/
void crypt_decryption(uint8_t *key, uint8_t *in, uint8_t *out, uint16_t size){
	
	if( size % 16 == 0 && size!=0 ){
		MX_CRYP_Init(key);
//		__HAL_CRYP_RESET_HANDLE_STATE(&hcryp);
		crypt_complete = 0;
		HAL_CRYP_AESECB_Decrypt_IT(&hcryp, in, size, out);
		while(crypt_complete==0){
			vTaskDelay(1);
		}
//		xSemaphoreTake(crypt_semaphore,100);
	}
}

/** 
* 加密写. 
* 由于AES256算法是16字节区域加密，对写起始地址及结束地址进行16倍数的调整，使用读-解密-改-加密-写方案. 
* 用于智能卡，备份存储卡，内部加密存储的加密
* @param[in]   dev:设备类型，addr:起始地址，len:长度，ptr:数据缓冲. 
* @param[out]  无.  
* @retval  0,写失败，其它：写入长度
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      Kend Deng于2019-03-29创建 
*/
uint16_t crypt_write(CARD_MANAGE_TypeDef *card_manage,uint16_t addr, uint16_t len, uint8_t *ptr){
	
	xSemaphoreTake(crypt_semaphore,portMAX_DELAY);
	
	uint16_t(*write_func)(CARD_MANAGE_TypeDef *card_manage,uint16_t addr, uint16_t len, uint8_t *ptr); 
	uint16_t(*read_func)(CARD_MANAGE_TypeDef *card_manage,uint16_t addr, uint16_t len, uint8_t *ptr); 
	
	CARD_MANAGE_TypeDef *card_ptr;
	
	if( card_manage==NULL ){
		write_func = at88sc_write_storage;
		read_func = at88sc_read_storage;
		card_ptr = NULL;
	}
	else{
		write_func = sc_write_storage;
		read_func = sc_read_storage;
		card_ptr = card_manage;
	}
	
	uint16_t start_block, end_block;
	start_block = addr/CRYPT_BLOCK_SIZE;
	end_block = (addr+len)/CRYPT_BLOCK_SIZE;
	uint16_t size = (end_block-start_block+1)*CRYPT_BLOCK_SIZE;
	
	uint8_t *read_buf = malloc(size);
	uint8_t	*write_buf = malloc(size);
	
	if( read_buf != NULL && write_buf != NULL ){
	
		memset(read_buf,0,size);
		memset(write_buf,0,size);
		
		uint8_t start_addr = addr%CRYPT_BLOCK_SIZE;
						
		//memcpy(read_block,temp+start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE);
		read_func(card_ptr,start_block*CRYPT_BLOCK_SIZE,size,read_buf);
//		crypt_log("write encrypt:");
//		crypt_dump(read_buf,size);
		crypt_decryption((uint8_t*)&default_password.encryption_key,read_buf,write_buf,size);
//		crypt_log("write plaintext read:");
//		crypt_dump(write_buf,size);
		
		memcpy(write_buf + start_addr, ptr, len);
//		crypt_log("write plaintext cpy:");
//		crypt_dump(write_buf,size);
		
		crypt_encryption((uint8_t*)&default_password.encryption_key,write_buf,read_buf,size);
		//memcpy(temp+start_block*CRYPT_BLOCK_SIZE,write_block,CRYPT_BLOCK_SIZE);
//		crypt_log("write decrypt:");
//		crypt_dump(read_buf,size);
		
		write_func(card_ptr, start_block*CRYPT_BLOCK_SIZE,size,read_buf);
		
		free(read_buf);
		free(write_buf);
	}
	else{
		if( read_buf!=NULL )
			free(read_buf);
		if( write_buf!=NULL )
			free(write_buf);
		len = 0;
	}
	
	xSemaphoreGive(crypt_semaphore);
	return len;
}

/** 
* 加密读. 
* 由于AES256算法是16字节区域加密，对读起始地址及结束地址进行16倍数的调整，使用读-解密-拷贝方案. 
* 用于智能卡，备份存储卡，内部加密存储的加密
* @param[in]   dev:设备类型，addr:起始地址，len:长度，ptr:数据缓冲. 
* @param[out]  无.  
* @retval  0,读失败，其它：读取长度
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      Kend Deng于2019-03-29创建 
*/
uint16_t crypt_read(CARD_MANAGE_TypeDef *card_manage,uint16_t addr, uint16_t len, uint8_t *ptr){
	
	xSemaphoreTake(crypt_semaphore,portMAX_DELAY);
	
	uint16_t(*write_func)(CARD_MANAGE_TypeDef *card_manage,uint16_t addr, uint16_t len, uint8_t *ptr); 
	uint16_t(*read_func)(CARD_MANAGE_TypeDef *card_manage,uint16_t addr, uint16_t len, uint8_t *ptr); 
	
	CARD_MANAGE_TypeDef *card_ptr;
	
	if( card_manage==NULL ){
		write_func = at88sc_write_storage;
		read_func = at88sc_read_storage;
		card_ptr = NULL;
	}
	else{
		write_func = sc_write_storage;
		read_func = sc_read_storage;
		card_ptr = card_manage;
	}
	
	uint16_t start_block, end_block;
	start_block = addr/CRYPT_BLOCK_SIZE;
	end_block = (addr+len)/CRYPT_BLOCK_SIZE;
	uint16_t size = (end_block-start_block+1)*CRYPT_BLOCK_SIZE;
	
	uint8_t *read_buf = malloc(size);
	uint8_t	*write_buf = malloc(size);
	
	if( read_buf != NULL && write_buf != NULL ){
		
		memset(read_buf,0,size);
		memset(write_buf,0,size);
	
		uint8_t start_addr = addr%CRYPT_BLOCK_SIZE;
						
		//memcpy(read_block,temp+start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE);
		read_func(card_ptr, start_block*CRYPT_BLOCK_SIZE,size,read_buf);
//		if( write_func == sc_write_storage ){
//			crypt_log("read encrypt:");
//			crypt_dump(read_buf,size);
//		}
		crypt_decryption((uint8_t*)&default_password.encryption_key,read_buf,write_buf,size);
//		crypt_log("read plaintext:");
//		crypt_dump(write_buf,size);
		
		memcpy(ptr, write_buf + start_addr, len);
		
		free(read_buf);
		free(write_buf);
	}
	else {
		if( read_buf!=NULL )
			free(read_buf);
		if( write_buf!=NULL )
			free(write_buf);
		len = 0;
	}
	
	xSemaphoreGive(crypt_semaphore);
	return len;
}

//void crypt_encryption(uint8_t *in, uint8_t *out){
//	
//	mbedtls_aes_context aes_ctx;
//	
//    mbedtls_aes_init(&aes_ctx);
//    //设置加密密钥  
//    mbedtls_aes_setkey_enc(&aes_ctx, default_password.encryption_key, 256);
//   
//    mbedtls_aes_crypt_ecb(&aes_ctx, MBEDTLS_AES_ENCRYPT, in, out);
//	
//	mbedtls_aes_free(&aes_ctx);
//	
//}	
//	
//void crypt_decryption(uint8_t *in, uint8_t *out){
//	
//	mbedtls_aes_context aes_ctx;
//	
//	mbedtls_aes_init(&aes_ctx);
//    //设置解密密钥  
//    mbedtls_aes_setkey_dec(&aes_ctx, default_password.encryption_key, 256);
//	
//    mbedtls_aes_crypt_ecb(&aes_ctx, MBEDTLS_AES_DECRYPT, in, out);
//   
//    mbedtls_aes_free(&aes_ctx);
//}

//uint16_t crypt_write(CRYPT_DEV_T dev,uint16_t addr, uint16_t len, uint8_t *ptr){
//	
//	uint8_t	read_block[CRYPT_BLOCK_SIZE];
//	uint8_t	write_block[CRYPT_BLOCK_SIZE];
//	uint8_t	plaintext_block[CRYPT_BLOCK_SIZE];
//	
//	uint16_t(*write_func)(uint16_t addr, uint16_t len, uint8_t *ptr); 
//	uint16_t(*read_func)(uint16_t addr, uint16_t len, uint8_t *ptr); 
//	
//	if( dev==CRYPT_SC ){
//		write_func = sc_write_storage;
//		read_func = sc_read_storage;
//	}
//	else if( dev==CRYPT_AT ){
//		write_func = at88sc_write_storage;
//		read_func = at88sc_read_storage;
//	}
//	
//	uint16_t start_block, end_block;
//	start_block = addr/CRYPT_BLOCK_SIZE;
//	end_block = (addr+len)/CRYPT_BLOCK_SIZE;
//	uint8_t block_addr = addr%CRYPT_BLOCK_SIZE;
//	uint8_t block_len;
//	uint16_t pos=addr;
//	uint8_t	copy_len=0;
//	
//	while( pos<addr+len ){
//		
		vTaskDelay(1);
//		
//		//memcpy(read_block,temp+start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE);
//		read_func(start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE,read_block);
//		crypt_decryption(read_block,plaintext_block);
//		
//		block_addr = pos%CRYPT_BLOCK_SIZE;
//		block_len = (block_addr%CRYPT_BLOCK_SIZE)?CRYPT_BLOCK_SIZE-block_addr:CRYPT_BLOCK_SIZE;
//		
//		if( (len+addr - pos) > block_len )
//			copy_len = block_len;
//		else
//			copy_len = (len+addr - pos);
//		
//		memcpy(plaintext_block + block_addr, ptr + pos - addr , copy_len);
//		crypt_encryption(plaintext_block,write_block);
//		//memcpy(temp+start_block*CRYPT_BLOCK_SIZE,write_block,CRYPT_BLOCK_SIZE);
//		write_func(start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE,write_block);
//		
//		pos += block_len;
//		
//		start_block++;
//	}
//}

//uint16_t crypt_read(CRYPT_DEV_T dev,uint16_t addr, uint16_t len, uint8_t *ptr){
//	
//	uint8_t	read_block[CRYPT_BLOCK_SIZE];
//	uint8_t	plaintext_block[CRYPT_BLOCK_SIZE];
//	
//	uint16_t(*write_func)(uint16_t addr, uint16_t len, uint8_t *ptr); 
//	uint16_t(*read_func)(uint16_t addr, uint16_t len, uint8_t *ptr); 
//	
//	if( dev==CRYPT_SC ){
//		write_func = sc_write_storage;
//		read_func = sc_read_storage;
//	}
//	else if( dev==CRYPT_AT ){
//		write_func = at88sc_write_storage;
//		read_func = at88sc_read_storage;
//	}
//	
//		uint16_t start_block, end_block;
//	start_block = addr/CRYPT_BLOCK_SIZE;
//	end_block = (addr+len)/CRYPT_BLOCK_SIZE;
//	uint8_t block_addr = addr%CRYPT_BLOCK_SIZE;
//	uint8_t block_len;
//	uint16_t pos=addr;
//	uint8_t	copy_len=0;
//	
//	while( pos<addr+len ){
//		
		vTaskDelay(1);
//		
//		read_func(start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE,read_block);
//		//memcpy(read_block,temp+start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE);
//		crypt_decryption(read_block,plaintext_block);
//		
//		block_addr = pos%CRYPT_BLOCK_SIZE;
//		block_len = (block_addr%CRYPT_BLOCK_SIZE)?CRYPT_BLOCK_SIZE-block_addr:CRYPT_BLOCK_SIZE;
//		
//		if( (len+addr - pos) > block_len )
//			copy_len = block_len;
//		else
//			copy_len = (len+addr - pos);
//		
//		memcpy(ptr + pos - addr, plaintext_block + block_addr , copy_len);
//		
//		pos += block_len;
//		
//		start_block++;
//	}
//}

//uint8_t temp[128]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40};

//void crypt_write(CRYPT_DEV_T dev,uint8_t *ptr,uint16_t addr, uint16_t len){
//	
//	uint8_t	read_block[CRYPT_BLOCK_SIZE];
//	uint8_t	write_block[CRYPT_BLOCK_SIZE];
//	uint8_t	plaintext_block[CRYPT_BLOCK_SIZE];
//	
//	uint16_t(*write_func)(uint16_t addr, uint16_t len, uint8_t *ptr); 
//	uint16_t(*read_func)(uint16_t addr, uint16_t len, uint8_t *ptr); 
//	
//	if( dev==CRYPT_SC ){
//		write_func = sc_write_storage;
//		read_func = sc_read_storage;
//	}
//	else if( dev==CRYPT_AT ){
//		write_func = at88sc_write_storage;
//		read_func = at88sc_read_storage;
//	}
//	
//	uint16_t start_block, end_block;
//	start_block = addr/CRYPT_BLOCK_SIZE;
//	end_block = (addr+len)/CRYPT_BLOCK_SIZE;
//	uint8_t block_addr = addr%CRYPT_BLOCK_SIZE;
//	uint8_t block_len;
//	uint16_t pos=addr;
//	uint8_t	copy_len=0;
//	
//	while( pos<addr+len ){
//		
//		memcpy(read_block,temp+start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE);
//		crypt_decryption(read_block,plaintext_block);
//		
//		block_addr = pos%CRYPT_BLOCK_SIZE;
//		block_len = (block_addr%CRYPT_BLOCK_SIZE)?CRYPT_BLOCK_SIZE-block_addr:CRYPT_BLOCK_SIZE;
//		
//		if( (len+addr - pos) > block_len )
//			copy_len = block_len;
//		else
//			copy_len = (len+addr - pos);
//		
//		memcpy(plaintext_block + block_addr, ptr + pos - addr , copy_len);
//		crypt_encryption(plaintext_block,write_block);
//		//write_func(start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE,plaintext_block);
//		memcpy(temp+start_block*CRYPT_BLOCK_SIZE,write_block,CRYPT_BLOCK_SIZE);
//		
//		pos += block_len;
//		
//		start_block++;
//	}
//}

//void crypt_read(CRYPT_DEV_T dev,uint8_t *ptr,uint16_t addr, uint16_t len){
//	
//	uint8_t	read_block[CRYPT_BLOCK_SIZE];
//	uint8_t	plaintext_block[CRYPT_BLOCK_SIZE];
//	
//	uint16_t(*write_func)(uint16_t addr, uint16_t len, uint8_t *ptr); 
//	uint16_t(*read_func)(uint16_t addr, uint16_t len, uint8_t *ptr); 
//	
//	if( dev==CRYPT_SC ){
//		write_func = sc_write_storage;
//		read_func = sc_read_storage;
//	}
//	else if( dev==CRYPT_AT ){
//		write_func = at88sc_write_storage;
//		read_func = at88sc_read_storage;
//	}
//	
//		uint16_t start_block, end_block;
//	start_block = addr/CRYPT_BLOCK_SIZE;
//	end_block = (addr+len)/CRYPT_BLOCK_SIZE;
//	uint8_t block_addr = addr%CRYPT_BLOCK_SIZE;
//	uint8_t block_len;
//	uint16_t pos=addr;
//	uint8_t	copy_len=0;
//	
//	while( pos<addr+len ){
//		
//		memcpy(read_block,temp+start_block*CRYPT_BLOCK_SIZE,CRYPT_BLOCK_SIZE);
//		crypt_decryption(read_block,plaintext_block);
//		
//		block_addr = pos%CRYPT_BLOCK_SIZE;
//		block_len = (block_addr%CRYPT_BLOCK_SIZE)?CRYPT_BLOCK_SIZE-block_addr:CRYPT_BLOCK_SIZE;
//		
//		if( (len+addr - pos) > block_len )
//			copy_len = block_len;
//		else
//			copy_len = (len+addr - pos);
//		
//		memcpy(ptr + pos - addr, plaintext_block + block_addr , copy_len);
//		
//		pos += block_len;
//		
//		start_block++;
//	}
//}

/** 
* AES256初始化. 
* 初始化DAM及互斥信号量. 
* @param[in]   无. 
* @param[out]  无.  
* @par 标识符 
* @retval  无.
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      Kend Deng于2019-03-29创建 
*/
FUN_STATUS_T crypt_init(void){
	
//	MX_DMA_Init();
	//MX_CRYP_Init();
	
	crypt_semaphore = xSemaphoreCreateMutex();
	if( crypt_semaphore==NULL )
		return FUN_ERROR;
	
	return FUN_OK;
}

void crypt_test(void){
	
	char str[]={0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xd0,0xd1,0xd2,0xd3};
	char read[33]={0};
	crypt_write(AT_SC,0,32,(uint8_t*)str);
	crypt_read(AT_SC,0,32,(uint8_t*)read);
}
stm32 AES256加密 串口IAP升级 bootloader程序
2301_77444154的博客
04-04 634
理论上，只要移植AES的.c和.h文件，并且你能将数据发送到单片机串口，就能用任意方式来对单片机进行升级，包括但不限于wifi，蓝牙，4G模块等。通过上位机将keil生成的BIN文件进行AES加密，得到新的加密文件，加密需要自己设置秘钥，加密升级包直接烧录不能运行。单片机接收到数据后，会根据你事先设置好的秘钥，对数据进行还原，再写入。本程序基于STM32ZET6，如果需要移植到别的系列。通过串口升级上位机将加密包发送到单片机，不同容量的芯片，页大小不同，解密完成，程序升级成功。串口升级的上位机软件。
STM32 AES256加密、串口IAP升级及bootloader程序实现
upuetot的博客
09-06 974
本程序的bootloader程序包括AES解密功能，能够根据预先设置的秘钥，对接收到的数据进行解密，并加载到Flash中运行。IAP（Incremental Application Programming）是一种常用的程序升级方法，它允许在设备运行时，通过串口或其他通信接口，将新的程序代码下载到设备中，实现程序的升级。理论上，只要移植AES的.c和.h文件，并且你能将数据发送到单片机串口，就能用任意方式来对单片机进行升级，包括但不限于wifi，蓝牙，4G模块等。通过串口升级上位机将加密包发送到单片机，
STM32的AES加密
06-23
STM32AES加密，采用软加密，是ST官方的库
STM32程序的加密与破解以及烧录方法
最新发布
weixin_42550185的博客
03-04 821
盗取他人的PCB和烧录文件，可以节省大大开发成本，何乐而不为呢。因此，就滋生了一些协助他人盗版的公司。为了防止被盗版和复制，单片机工程师也是煞费苦心，对硬件和软件均采取了防盗版措施。
AES256加解密
jdd92的博客
11-09 5192
本地有个plist文件，需要对里面的几个字段加密，刚开始用的base64加密的，老大说太简单，网上搜罗了一下，觉得这个加密法挺合适： AES:高级加密标准(Advanced Encryption Standard) 　　 加密步骤: 字符串经过AES加密得到NSData类型数据，然后在对加密后的NSData数据进行Base64转码，得出最终的字符串 　　 解密步骤: 对要解密的字符串进行Base64解码得到NSData类型数据，然后对NSData数据经过AES解密，得出原字符串 //创建一...
STM32利用AES加密数据、解密数据
宁静致远的博客
03-15 5157
1、AES_KEY_LENGTH取值只能是128，192 和 256。3、加密、解密数据长度为AES_KEY_LENGTH/8的整数倍字节。2、密钥和向量表长度为AES_KEY_LENGTH/8个字节。
【AES256】Java实现AES256加解密
热门推荐
求索
11-06 1万+
Java实现AES256加解密记录参考
STM32F4 AES加密解密测试程序
10-08
该STM32F4 AES加密解密测试程序是一个针对STM32F4系列微控制器的专门用于数据加密和解密的软件工具，它利用AES算法以及PKCS7填充算法来确保数据安全，通过串口1接收不定长数据进行加密解密测试。程序的开发和测试...
SecAESSTM32:用于消费类组件（STM32F3STM32F4 系列）的 AES-128 消息解密加密的 C 库和汇编程序
05-30
已测试代码的平台是 STM32F3 和 STM32F4，但应与使用 Thumb-2 ARMv7-M 指令集的任何 Cortex-M3/Cortex-M4 兼容。 STM32 MCU 不是安全的； 尤其是，并未采取任何措施来增强其抵抗侧信道攻击和故障注入（例如，时钟...
STM32 加密算法 源码代码（包括AES的5种模式）
09-15
本资源提供的是一套STM32加密算法的源码，涵盖了AES（高级加密标准）的五种工作模式，以确保数据在传输和存储过程中的安全性。 AES是目前最广泛应用的对称加密算法之一，它基于替换和置换的原理，提供了高效且强大...
aes_256加解密算法模型
09-17
详细的AES_256加解密算法模型,王队各位猿们有用
STM32 IAP程序代码，固件AES256 加密，iap烧写自动解密
11-21
可以把固件加密后通过IAP下载，适合产品自动升级，保护固件程序，防破解。 记得评分后归还积分
STM32F103程序AES加密.zip_STM32 AES加密_aes stm32f103_stm32f103 硬件aes_
07-14
STM32的AES加解密例程，基于官方加密库
C语言 stm32 AES加密解密
06-22
stm32加解密工具类，直接可用，采用AES 对称加密解密 AES_Decrypt(expressText,cipherText , aesKey);
STM32AES加密程序.zip
05-30
STM32利用AES加密数据、解密数据源代码，代码已验证可以拿来直接使用。具体使用方法可以参考我的博客说明。
stm32 AES256加密 串口IAP升级 bootloader程序通过上位机将keil生成的BIN文件进行AES加密
MhMysQb的博客
11-12 1625
通过串口升级上位机将加密包发送到单片机，单片机接收到数据后，会根据设置好的秘钥，对数据进行还原，再写入。本文介绍了一种基于STM32芯片的AES256加密串口IAP升级Bootloader程序的设计和实现方法，该程序可以实现程序的自动升级和传输安全，并且可以通过移植AES的.c和.h文件很容易地实现扩展。为了解决这个问题，本文将介绍一种基于STM32芯片的AES256加密串口IAP升级Bootloader程序的设计和实现方法，它可以保证升级过程的安全性和稳定性，同时提高了升级的速度，可靠性和扩展性。
AES256加解密java语言实现
ZhijunHong的博客
03-16 1294
AES256加解密java语言实现 转载请标明出处：https://blog.youkuaiyun.com/ZhijunHong/article/details/114870177，谢谢~ 写在前面 基于项目安全性需要，有时候我们的项目会使用AES 256加解密算法。以下，是针对实现AES256 Padding7加密算法实现的关键步骤解析以及此过程遇到的一些问题总结。 GitHub链接地址：https://github.com/zhijunhong/common_utils/tree/master/aes256 一些概
STM32硬件AES
John Lee 的专栏
09-02 5581
好像没什么人关注这个硬件AES，我来简单看下使用方式 简介 这个AES硬件几乎支持AES的所有加解密模式，并且支持2个DMA，一个输入一个输出。 AES主要的特性 支持128和256位密钥，带32位数据缓存，带IV寄存器 AES功能描述 硬件加速器支持4种模式： 使用存储在 AES_KEYRx 寄存器中的密钥进行加密。 在启用AES之前就把扩展密钥计算好并存放在 AES_KEYRx 寄存器中，这个模式独立于 AES 链接模式选择。 用 AES_KEYRx 中的密钥进行解密 密钥派生和解密同时进行，计
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

纵向深耕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值