sean-m
/
kendryte-standalone-sdk
mirror of https://github.com/kendryte/kendryte-standalone-sdk.git
1
0
Fork 0
Code Issues Releases Wiki Activity
kendryte-standalone-sdk/lib/drivers/aes.c

800 lines
32 KiB
C
Raw Blame History

/* Copyright 2018 Canaan Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdlib.h>
#include <string.h>
#include "aes.h"
#include "sysctl.h"
#include "utils.h"
volatile aes_t *const aes = (volatile aes_t *)AES_BASE_ADDR;
static void aes_clk_init()
{
sysctl_clock_enable(SYSCTL_CLOCK_AES);
sysctl_reset(SYSCTL_RESET_AES);
}
static void aes_write_aad(uint32_t aad_data)
{
aes->aes_aad_data = aad_data;
}
static void aes_write_text(uint32_t text_data)
{
aes->aes_text_data = text_data;
}
static void gcm_write_tag(uint32_t *tag)
{
aes->gcm_in_tag[0] = tag[3];
aes->gcm_in_tag[1] = tag[2];
aes->gcm_in_tag[2] = tag[1];
aes->gcm_in_tag[3] = tag[0];
}
static uint32_t aes_get_data_in_flag(void)
{
return aes->data_in_flag;
}
static uint32_t aes_get_data_out_flag(void)
{
return aes->data_out_flag;
}
static uint32_t gcm_get_tag_in_flag(void)
{
return aes->tag_in_flag;
}
static uint32_t aes_read_out_data(void)
{
return aes->aes_out_data;
}
static uint32_t gcm_get_tag_chk(void)
{
return aes->tag_chk;
}
static void gcm_clear_chk_tag(void)
{
aes->tag_clear = 0;
}
static uint32_t gcm_check_tag(uint32_t *gcm_tag)
{
while(!gcm_get_tag_in_flag())
;
gcm_write_tag(gcm_tag);
while(!gcm_get_tag_chk())
;
if(gcm_get_tag_chk() == 0x2)
{
gcm_clear_chk_tag();
return 1;
} else
{
gcm_clear_chk_tag();
return 0;
}
}
void gcm_get_tag(uint8_t *gcm_tag)
{
uint32_t uint32_tag;
uint8_t i = 0;
uint32_tag = aes->gcm_out_tag[3];
gcm_tag[i++] = (uint8_t)((uint32_tag >> 24) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag >> 16) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag >> 8) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag)&0xff);
uint32_tag = aes->gcm_out_tag[2];
gcm_tag[i++] = (uint8_t)((uint32_tag >> 24) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag >> 16) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag >> 8) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag)&0xff);
uint32_tag = aes->gcm_out_tag[1];
gcm_tag[i++] = (uint8_t)((uint32_tag >> 24) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag >> 16) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag >> 8) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag)&0xff);
uint32_tag = aes->gcm_out_tag[0];
gcm_tag[i++] = (uint8_t)((uint32_tag >> 24) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag >> 16) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag >> 8) & 0xff);
gcm_tag[i++] = (uint8_t)((uint32_tag)&0xff);
gcm_check_tag((uint32_t *)gcm_tag);
}
void aes_init(uint8_t *input_key, size_t input_key_len, uint8_t *iv, size_t iv_len, uint8_t *gcm_aad,
aes_cipher_mode_t cipher_mode, aes_encrypt_sel_t encrypt_sel, size_t gcm_aad_len, size_t input_data_len)
{
size_t remainder, uint32_num, uint8_num, i;
uint32_t uint32_data;
uint8_t uint8_data[4] = {0};
size_t padding_len = input_data_len;
aes_clk_init();
if((cipher_mode == AES_ECB) || (cipher_mode == AES_CBC))
padding_len = ((input_data_len + 15) / 16) * 16;
aes->aes_endian |= 1;
uint32_num = input_key_len / 4;
for(i = 0; i < uint32_num; i++)
{
if(i < 4)
aes->aes_key[i] = *((uint32_t *)(&input_key[input_key_len - (4 * i) - 4]));
else
aes->aes_key_ext[i - 4] = *((uint32_t *)(&input_key[input_key_len - (4 * i) - 4]));
}
uint32_num = iv_len / 4;
for(i = 0; i < uint32_num; i++)
aes->aes_iv[i] = *((uint32_t *)(&iv[iv_len - (4 * i) - 4]));
aes->mode_ctl.kmode = input_key_len / 8 - 2; /* b'00:AES_128 b'01:AES_192 b'10:AES_256 b'11:RESERVED */
aes->mode_ctl.cipher_mode = cipher_mode;
aes->encrypt_sel = encrypt_sel;
aes->gb_aad_num = gcm_aad_len - 1;
aes->gb_pc_num = padding_len - 1;
aes->gb_aes_en |= 1;
if(cipher_mode == AES_GCM)
{
uint32_num = gcm_aad_len / 4;
for(i = 0; i < uint32_num; i++)
{
uint32_data = *((uint32_t *)(&gcm_aad[i * 4]));
while(!aes_get_data_in_flag())
;
aes_write_aad(uint32_data);
}
uint8_num = 4 * uint32_num;
remainder = gcm_aad_len % 4;
if(remainder)
{
switch(remainder)
{
case 1:
uint8_data[0] = gcm_aad[uint8_num];
break;
case 2:
uint8_data[0] = gcm_aad[uint8_num];
uint8_data[1] = gcm_aad[uint8_num + 1];
break;
case 3:
uint8_data[0] = gcm_aad[uint8_num];
uint8_data[1] = gcm_aad[uint8_num + 1];
uint8_data[2] = gcm_aad[uint8_num + 2];
break;
default:
break;
}
uint32_data = *((uint32_t *)(&uint8_data[0]));
while(!aes_get_data_in_flag())
;
aes_write_aad(uint32_data);
}
}
}
static void aes_input_bytes(const uint8_t *input_data, size_t input_data_len, aes_cipher_mode_t cipher_mode)
{
size_t padding_len, uint32_num, uint8_num, remainder, i;
uint32_t uint32_data;
uint8_t uint8_data[4] = {0};
padding_len = ((input_data_len + 15) / 16) * 16;
uint32_num = input_data_len / 4;
for(i = 0; i < uint32_num; i++)
{
uint32_data = *((uint32_t *)(&input_data[i * 4]));
while(!aes_get_data_in_flag())
;
aes_write_text(uint32_data);
}
uint8_num = 4 * uint32_num;
remainder = input_data_len % 4;
if(remainder)
{
switch(remainder)
{
case 1:
uint8_data[0] = input_data[uint8_num];
break;
case 2:
uint8_data[0] = input_data[uint8_num];
uint8_data[1] = input_data[uint8_num + 1];
break;
case 3:
uint8_data[0] = input_data[uint8_num];
uint8_data[1] = input_data[uint8_num + 1];
uint8_data[2] = input_data[uint8_num + 2];
break;
default:
break;
}
uint32_data = *((uint32_t *)(&uint8_data[0]));
while(!aes_get_data_in_flag())
;
aes_write_text(uint32_data);
}
if((cipher_mode == AES_ECB) || (cipher_mode == AES_CBC))
{
uint32_num = (padding_len - input_data_len) / 4;
for(i = 0; i < uint32_num; i++)
{
while(!aes_get_data_in_flag())
;
aes_write_text(0);
}
uint32_num = padding_len / 4;
}
}
static void process_less_80_bytes(uint8_t *input_data, uint8_t *output_data, size_t input_data_len, aes_cipher_mode_t cipher_mode)
{
size_t padding_len, uint32_num, uint8_num, remainder, i;
uint32_t uint32_data;
uint8_t uint8_data[4] = {0};
padding_len = ((input_data_len + 15) / 16) * 16;
uint32_num = input_data_len / 4;
for(i = 0; i < uint32_num; i++)
{
uint32_data = *((uint32_t *)(&input_data[i * 4]));
while(!aes_get_data_in_flag())
;
aes_write_text(uint32_data);
}
uint8_num = 4 * uint32_num;
remainder = input_data_len % 4;
if(remainder)
{
switch(remainder)
{
case 1:
uint8_data[0] = input_data[uint8_num];
break;
case 2:
uint8_data[0] = input_data[uint8_num];
uint8_data[1] = input_data[uint8_num + 1];
break;
case 3:
uint8_data[0] = input_data[uint8_num];
uint8_data[1] = input_data[uint8_num + 1];
uint8_data[2] = input_data[uint8_num + 2];
break;
default:
break;
}
uint32_data = *((uint32_t *)(&uint8_data[0]));
while(!aes_get_data_in_flag())
;
aes_write_text(uint32_data);
}
if((cipher_mode == AES_ECB) || (cipher_mode == AES_CBC))
{
uint32_num = (padding_len - input_data_len) / 4;
for(i = 0; i < uint32_num; i++)
{
while(!aes_get_data_in_flag())
;
aes_write_text(0);
}
uint32_num = padding_len / 4;
}
for(i = 0; i < uint32_num; i++)
{
while(!aes_get_data_out_flag())
;
*((uint32_t *)(&output_data[i * 4])) = aes_read_out_data();
}
if((cipher_mode == AES_GCM) && (remainder))
{
while(!aes_get_data_out_flag())
;
*((uint32_t *)(&uint8_data[0])) = aes_read_out_data();
switch(remainder)
{
case 1:
output_data[uint32_num * 4] = uint8_data[0];
break;
case 2:
output_data[uint32_num * 4] = uint8_data[0];
output_data[(i * 4) + 1] = uint8_data[1];
break;
case 3:
output_data[uint32_num * 4] = uint8_data[0];
output_data[(i * 4) + 1] = uint8_data[1];
output_data[(i * 4) + 2] = uint8_data[2];
break;
default:
break;
}
}
}
void aes_process(uint8_t *input_data, uint8_t *output_data, size_t input_data_len, aes_cipher_mode_t cipher_mode)
{
size_t temp_len = 0;
uint32_t i = 0;
if(input_data_len >= 80)
{
for(i = 0; i < (input_data_len / 80); i++)
process_less_80_bytes(&input_data[i * 80], &output_data[i * 80], 80, cipher_mode);
}
temp_len = input_data_len % 80;
if(temp_len)
process_less_80_bytes(&input_data[i * 80], &output_data[i * 80], temp_len, cipher_mode);
}
void aes_ecb128_hard_decrypt(uint8_t *input_key, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(input_key, AES_128, NULL, 0L, NULL, AES_ECB, AES_HARD_DECRYPTION, 0L, input_len);
aes_process(input_data, output_data, padding_len, AES_ECB);
}
void aes_ecb128_hard_encrypt(uint8_t *input_key, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
aes_init(input_key, AES_128, NULL, 0L, NULL, AES_ECB, AES_HARD_ENCRYPTION, 0L, input_len);
aes_process(input_data, output_data, input_len, AES_ECB);
}
void aes_ecb192_hard_decrypt(uint8_t *input_key, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(input_key, AES_192, NULL, 0L, NULL, AES_ECB, AES_HARD_DECRYPTION, 0L, input_len);
aes_process(input_data, output_data, padding_len, AES_ECB);
}
void aes_ecb192_hard_encrypt(uint8_t *input_key, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
aes_init(input_key, AES_192, NULL, 0L, NULL, AES_ECB, AES_HARD_ENCRYPTION, 0L, input_len);
aes_process(input_data, output_data, input_len, AES_ECB);
}
void aes_ecb256_hard_decrypt(uint8_t *input_key, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(input_key, AES_256, NULL, 0L, NULL, AES_ECB, AES_HARD_DECRYPTION, 0L, input_len);
aes_process(input_data, output_data, padding_len, AES_ECB);
}
void aes_ecb256_hard_encrypt(uint8_t *input_key, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
aes_init(input_key, AES_256, NULL, 0L, NULL, AES_ECB, AES_HARD_ENCRYPTION, 0L, input_len);
aes_process(input_data, output_data, input_len, AES_ECB);
}
void aes_cbc128_hard_decrypt(cbc_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(context->input_key, AES_128, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_DECRYPTION, 0L, input_len);
aes_process(input_data, output_data, padding_len, AES_CBC);
}
void aes_cbc128_hard_encrypt(cbc_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
aes_init(context->input_key, AES_128, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_ENCRYPTION, 0L, input_len);
aes_process(input_data, output_data, input_len, AES_CBC);
}
void aes_cbc192_hard_decrypt(cbc_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(context->input_key, AES_192, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_DECRYPTION, 0L, input_len);
aes_process(input_data, output_data, padding_len, AES_CBC);
}
void aes_cbc192_hard_encrypt(cbc_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
aes_init(context->input_key, AES_192, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_ENCRYPTION, 0L, input_len);
aes_process(input_data, output_data, input_len, AES_CBC);
}
void aes_cbc256_hard_decrypt(cbc_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(context->input_key, AES_256, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_DECRYPTION, 0L, input_len);
aes_process(input_data, output_data, padding_len, AES_CBC);
}
void aes_cbc256_hard_encrypt(cbc_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data)
{
aes_init(context->input_key, AES_256, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_ENCRYPTION, 0L, input_len);
aes_process(input_data, output_data, input_len, AES_CBC);
}
void aes_gcm128_hard_decrypt(gcm_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data, uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_128, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_DECRYPTION, context->gcm_aad_len, input_len);
aes_process(input_data, output_data, input_len, AES_GCM);
gcm_get_tag(gcm_tag);
}
void aes_gcm128_hard_encrypt(gcm_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data, uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_128, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_ENCRYPTION, context->gcm_aad_len, input_len);
aes_process(input_data, output_data, input_len, AES_GCM);
gcm_get_tag(gcm_tag);
}
void aes_gcm192_hard_decrypt(gcm_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data, uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_192, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_DECRYPTION, context->gcm_aad_len, input_len);
aes_process(input_data, output_data, input_len, AES_GCM);
gcm_get_tag(gcm_tag);
}
void aes_gcm192_hard_encrypt(gcm_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data, uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_192, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_ENCRYPTION, context->gcm_aad_len, input_len);
aes_process(input_data, output_data, input_len, AES_GCM);
gcm_get_tag(gcm_tag);
}
void aes_gcm256_hard_decrypt(gcm_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data, uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_256, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_DECRYPTION, context->gcm_aad_len, input_len);
aes_process(input_data, output_data, input_len, AES_GCM);
gcm_get_tag(gcm_tag);
}
void aes_gcm256_hard_encrypt(gcm_context_t *context, uint8_t *input_data, size_t input_len, uint8_t *output_data, uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_256, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_ENCRYPTION, context->gcm_aad_len, input_len);
aes_process(input_data, output_data, input_len, AES_GCM);
gcm_get_tag(gcm_tag);
}
void aes_ecb128_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
uint8_t *input_key,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(input_key, AES_128, NULL, 0L, NULL, AES_ECB, AES_HARD_DECRYPTION, 0L, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_ECB);
dmac_wait_done(dma_receive_channel_num);
}
void aes_ecb128_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
uint8_t *input_key,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
aes_init(input_key, AES_128, NULL, 0L, NULL, AES_ECB, AES_HARD_ENCRYPTION, 0L, input_len);
size_t padding_len = ((input_len + 15) / 16) * 16;
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_ECB);
dmac_wait_done(dma_receive_channel_num);
}
void aes_ecb192_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
uint8_t *input_key,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(input_key, AES_192, NULL, 0L, NULL, AES_ECB, AES_HARD_DECRYPTION, 0L, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_ECB);
dmac_wait_done(dma_receive_channel_num);
}
void aes_ecb192_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
uint8_t *input_key,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
aes_init(input_key, AES_192, NULL, 0L, NULL, AES_ECB, AES_HARD_ENCRYPTION, 0L, input_len);
size_t padding_len = ((input_len + 15) / 16) * 16;
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_ECB);
dmac_wait_done(dma_receive_channel_num);
}
void aes_ecb256_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
uint8_t *input_key,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(input_key, AES_256, NULL, 0L, NULL, AES_ECB, AES_HARD_DECRYPTION, 0L, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_ECB);
dmac_wait_done(dma_receive_channel_num);
}
void aes_ecb256_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
uint8_t *input_key,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
aes_init(input_key, AES_256, NULL, 0L, NULL, AES_ECB, AES_HARD_ENCRYPTION, 0L, input_len);
size_t padding_len = ((input_len + 15) / 16) * 16;
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_ECB);
dmac_wait_done(dma_receive_channel_num);
}
void aes_cbc128_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
cbc_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(context->input_key, AES_128, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_DECRYPTION, 0L, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_CBC);
dmac_wait_done(dma_receive_channel_num);
}
void aes_cbc128_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
cbc_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
aes_init(context->input_key, AES_128, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_ENCRYPTION, 0L, input_len);
size_t padding_len = ((input_len + 15) / 16) * 16;
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_CBC);
dmac_wait_done(dma_receive_channel_num);
}
void aes_cbc192_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
cbc_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(context->input_key, AES_192, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_DECRYPTION, 0L, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_CBC);
dmac_wait_done(dma_receive_channel_num);
}
void aes_cbc192_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
cbc_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
aes_init(context->input_key, AES_192, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_ENCRYPTION, 0L, input_len);
size_t padding_len = ((input_len + 15) / 16) * 16;
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_CBC);
dmac_wait_done(dma_receive_channel_num);
}
void aes_cbc256_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
cbc_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
size_t padding_len = ((input_len + 15) / 16) * 16;
aes_init(context->input_key, AES_256, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_DECRYPTION, 0L, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_CBC);
dmac_wait_done(dma_receive_channel_num);
}
void aes_cbc256_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
cbc_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data)
{
aes_init(context->input_key, AES_256, context->iv, IV_LEN_128, NULL, AES_CBC, AES_HARD_ENCRYPTION, 0L, input_len);
size_t padding_len = ((input_len + 15) / 16) * 16;
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, padding_len >> 2);
aes_input_bytes(input_data, input_len, AES_CBC);
dmac_wait_done(dma_receive_channel_num);
}
void aes_gcm128_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
gcm_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data,
uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_128, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_DECRYPTION, context->gcm_aad_len, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, (input_len + 3) >> 2);
aes_input_bytes(input_data, input_len, AES_GCM);
dmac_wait_done(dma_receive_channel_num);
gcm_get_tag(gcm_tag);
}
void aes_gcm128_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
gcm_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data,
uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_128, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_ENCRYPTION, context->gcm_aad_len, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, (input_len + 3) >> 2);
aes_input_bytes(input_data, input_len, AES_GCM);
dmac_wait_done(dma_receive_channel_num);
gcm_get_tag(gcm_tag);
}
void aes_gcm192_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
gcm_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data,
uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_192, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_DECRYPTION, context->gcm_aad_len, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, (input_len + 3) >> 2);
aes_input_bytes(input_data, input_len, AES_GCM);
dmac_wait_done(dma_receive_channel_num);
gcm_get_tag(gcm_tag);
}
void aes_gcm192_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
gcm_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data,
uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_192, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_ENCRYPTION, context->gcm_aad_len, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, (input_len + 3) >> 2);
aes_input_bytes(input_data, input_len, AES_GCM);
dmac_wait_done(dma_receive_channel_num);
gcm_get_tag(gcm_tag);
}
void aes_gcm256_hard_decrypt_dma(dmac_channel_number_t dma_receive_channel_num,
gcm_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data,
uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_256, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_DECRYPTION, context->gcm_aad_len, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, (input_len + 3) >> 2);
aes_input_bytes(input_data, input_len, AES_GCM);
dmac_wait_done(dma_receive_channel_num);
gcm_get_tag(gcm_tag);
}
void aes_gcm256_hard_encrypt_dma(dmac_channel_number_t dma_receive_channel_num,
gcm_context_t *context,
uint8_t *input_data,
size_t input_len,
uint8_t *output_data,
uint8_t *gcm_tag)
{
aes_init(context->input_key, AES_256, context->iv, IV_LEN_96, context->gcm_aad,
AES_GCM, AES_HARD_ENCRYPTION, context->gcm_aad_len, input_len);
sysctl_dma_select(dma_receive_channel_num, SYSCTL_DMA_SELECT_AES_REQ);
aes->dma_sel = 1;
dmac_set_single_mode(dma_receive_channel_num, (void *)(&aes->aes_out_data), output_data, DMAC_ADDR_NOCHANGE, DMAC_ADDR_INCREMENT,
DMAC_MSIZE_4, DMAC_TRANS_WIDTH_32, (input_len + 3) >> 2);
aes_input_bytes(input_data, input_len, AES_GCM);
dmac_wait_done(dma_receive_channel_num);
gcm_get_tag(gcm_tag);
}
Reference in New Issue View Git Blame Copy Permalink