985 lines
29 KiB
C
985 lines
29 KiB
C
|
/* Copyright (c) 2019-2025 Allwinner Technology Co., Ltd. ALL rights reserved.
|
|||
|
|
|
|||
|
|
* Allwinner is a trademark of Allwinner Technology Co.,Ltd., registered in
|
|||
|
|
* the the People's Republic of China and other countries.
|
|||
|
|
* All Allwinner Technology Co.,Ltd. trademarks are used with permission.
|
|||
|
|
|
|||
|
|
* DISCLAIMER
|
|||
|
|
* THIRD PARTY LICENCES MAY BE REQUIRED TO IMPLEMENT THE SOLUTION/PRODUCT.
|
|||
|
|
* IF YOU NEED TO INTEGRATE THIRD PARTY’S TECHNOLOGY (SONY, DTS, DOLBY, AVS OR MPEGLA, ETC.)
|
|||
|
|
* IN ALLWINNERS’SDK OR PRODUCTS, YOU SHALL BE SOLELY RESPONSIBLE TO OBTAIN
|
|||
|
|
* ALL APPROPRIATELY REQUIRED THIRD PARTY LICENCES.
|
|||
|
|
* ALLWINNER SHALL HAVE NO WARRANTY, INDEMNITY OR OTHER OBLIGATIONS WITH RESPECT TO MATTERS
|
|||
|
|
* COVERED UNDER ANY REQUIRED THIRD PARTY LICENSE.
|
|||
|
|
* YOU ARE SOLELY RESPONSIBLE FOR YOUR USAGE OF THIRD PARTY’S TECHNOLOGY.
|
|||
|
|
|
|||
|
|
|
|||
|
|
* THIS SOFTWARE IS PROVIDED BY ALLWINNER"AS IS" AND TO THE MAXIMUM EXTENT
|
|||
|
|
* PERMITTED BY LAW, ALLWINNER EXPRESSLY DISCLAIMS ALL WARRANTIES OF ANY KIND,
|
|||
|
|
* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION REGARDING
|
|||
|
|
* THE TITLE, NON-INFRINGEMENT, ACCURACY, CONDITION, COMPLETENESS, PERFORMANCE
|
|||
|
|
* OR MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|||
|
|
* IN NO EVENT SHALL ALLWINNER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|||
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|||
|
|
* LOSS OF USE, DATA, OR PROFITS, OR BUSINESS INTERRUPTION)
|
|||
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|||
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|||
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|||
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
#include <stdlib.h>
|
|||
|
|
#include <string.h>
|
|||
|
|
#include <interrupt.h>
|
|||
|
|
#include <hal_cache.h>
|
|||
|
|
#include <hal_mem.h>
|
|||
|
|
#include <hal_osal.h>
|
|||
|
|
#include <hal_sem.h>
|
|||
|
|
#include <hal_timer.h>
|
|||
|
|
#include <sunxi_hal_ce.h>
|
|||
|
|
#include "ce_common.h"
|
|||
|
|
#include "hal_ce.h"
|
|||
|
|
#include "ce_reg.h"
|
|||
|
|
#include "platform_ce.h"
|
|||
|
|
|
|||
|
|
//#define CE_NO_IRQ
|
|||
|
|
#define CE_WAIT_TIME (50000)
|
|||
|
|
|
|||
|
|
#ifndef CE_NO_IRQ
|
|||
|
|
static hal_sem_t ce_sem;
|
|||
|
|
#endif
|
|||
|
|
//static rt_wqueue_t ce_wqueue;
|
|||
|
|
|
|||
|
|
void ce_print_hex(char *_data, int _len, void *_addr)
|
|||
|
|
{
|
|||
|
|
int i, j;
|
|||
|
|
char last[128] = {0};
|
|||
|
|
|
|||
|
|
CE_DBG("---------------- The valid len = %d ----------------\n",
|
|||
|
|
_len);
|
|||
|
|
for (i = 0; i < _len/8; i++) {
|
|||
|
|
CE_DBG("%p: %02X %02X %02X %02X %02X %02X %02X %02X\n",
|
|||
|
|
i*8 + _addr,
|
|||
|
|
_data[i*8+0], _data[i*8+1], _data[i*8+2], _data[i*8+3],
|
|||
|
|
_data[i*8+4], _data[i*8+5], _data[i*8+6], _data[i*8+7]);
|
|||
|
|
}
|
|||
|
|
for (j = 0; j < _len%8; j++) {
|
|||
|
|
if (j == 0)
|
|||
|
|
snprintf(last, 12, "%p:", i * 8 + _addr);
|
|||
|
|
snprintf(last + 11 + j*3, 4, " %02X", _data[i*8 + j]);
|
|||
|
|
if (j == _len % 8 - 1)
|
|||
|
|
CE_DBG("%s\n", last);
|
|||
|
|
}
|
|||
|
|
CE_DBG("----------------------------------------------------\n");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void ce_print_task_info(ce_task_desc_t *task)
|
|||
|
|
{
|
|||
|
|
CE_DBG("-----------task_info------\n");
|
|||
|
|
CE_DBG("task = 0x%lx\n", (uint32_t)task);
|
|||
|
|
CE_DBG("task->comm_ctl = 0x%lx\n", task->comm_ctl);
|
|||
|
|
CE_DBG("task->sym_ctl = 0x%lx\n", task->sym_ctl);
|
|||
|
|
CE_DBG("task->asym_ctl = 0x%lx\n", task->asym_ctl);
|
|||
|
|
CE_DBG("task->chan_id = 0x%lx\n", task->chan_id);
|
|||
|
|
CE_DBG("task->ctr_addr = 0x%lx\n", task->ctr_addr);
|
|||
|
|
CE_DBG("task->data_len = 0x%lx\n", task->data_len);
|
|||
|
|
CE_DBG("task->iv_addr = 0x%lx\n", task->iv_addr);
|
|||
|
|
CE_DBG("task->key_addr = 0x%lx\n", task->key_addr);
|
|||
|
|
CE_DBG("task->src[0].addr = 0x%lx\n", task->src[0].addr);
|
|||
|
|
CE_DBG("task->src[0].len = 0x%lx\n", task->src[0].len);
|
|||
|
|
CE_DBG("task->dst[0].addr = 0x%lx\n", task->dst[0].addr);
|
|||
|
|
CE_DBG("task->dst[0].len = 0x%lx\n", task->dst[0].len);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#ifndef CE_NO_IRQ
|
|||
|
|
static hal_irqreturn_t ce_irq_handler(void *data)
|
|||
|
|
{
|
|||
|
|
int i;
|
|||
|
|
int ret;
|
|||
|
|
int pending = 0;
|
|||
|
|
|
|||
|
|
pending = hal_ce_pending_get();
|
|||
|
|
for (i = 0; i < CE_FLOW_NUM; i++) {
|
|||
|
|
if (pending & (CE_CHAN_PENDING << i)) {
|
|||
|
|
CE_DBG("Chan %d completed. pending: %#x\n", i, pending);
|
|||
|
|
hal_ce_pending_clear(i);
|
|||
|
|
ret = hal_sem_post(ce_sem);
|
|||
|
|
if (ret == 0) {
|
|||
|
|
;
|
|||
|
|
} else {
|
|||
|
|
CE_ERR("hal_sem_post FAIL \n");
|
|||
|
|
}
|
|||
|
|
#if 0
|
|||
|
|
rt_wqueue_wakeup(&ce_wqueue, NULL);
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return HAL_IRQ_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int ce_irq_request(void)
|
|||
|
|
{
|
|||
|
|
#ifdef CONFIG_ARCH_SUN20IW2P1
|
|||
|
|
uint32_t irqn = SUNXI_IRQ_CE_NS;
|
|||
|
|
|
|||
|
|
if (hal_request_irq(irqn, ce_irq_handler, "ce", NULL) < 0) {
|
|||
|
|
CE_ERR("request irq error\n");
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
hal_enable_irq(irqn);
|
|||
|
|
#else
|
|||
|
|
uint32_t irqn = SUNXI_IRQ_CE;
|
|||
|
|
|
|||
|
|
if (request_irq(irqn, ce_irq_handler, 0, "crypto", NULL) < 0) {
|
|||
|
|
CE_ERR("Cannot request IRQ\n");
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
enable_irq(irqn);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
int sunxi_ce_init(void)
|
|||
|
|
{
|
|||
|
|
int ret = 0;
|
|||
|
|
|
|||
|
|
hal_ce_clock_init();
|
|||
|
|
#ifndef CE_NO_IRQ
|
|||
|
|
ret = ce_irq_request();
|
|||
|
|
if (ret < 0) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ce_sem = hal_sem_create(0);
|
|||
|
|
if (ce_sem == NULL) {
|
|||
|
|
CE_ERR("hal_sem_create fail\n");
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if 0
|
|||
|
|
rt_wqueue_init(&ce_wqueue);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int sunxi_ce_uninit(void)
|
|||
|
|
{
|
|||
|
|
#ifndef CE_NO_IRQ
|
|||
|
|
if (ce_sem)
|
|||
|
|
hal_sem_delete(ce_sem);
|
|||
|
|
|
|||
|
|
#ifdef CONFIG_ARCH_SUN20IW2P1
|
|||
|
|
hal_free_irq(SUNXI_IRQ_CE_NS);
|
|||
|
|
#else
|
|||
|
|
hal_free_irq(SUNXI_IRQ_CE);
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void ce_task_desc_init(ce_task_desc_t *task, uint32_t flow)
|
|||
|
|
{
|
|||
|
|
memset((void *)task, 0x0, sizeof(ce_task_desc_t));
|
|||
|
|
task->chan_id = flow;
|
|||
|
|
hal_ce_task_enable(task);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static ce_task_desc_t *ce_aes_config(uint32_t dir, uint32_t type, uint32_t mode,
|
|||
|
|
uint8_t *key_buf, uint32_t key_length)
|
|||
|
|
{
|
|||
|
|
ce_task_desc_t *task = NULL;
|
|||
|
|
uint32_t flow = 1;
|
|||
|
|
|
|||
|
|
task = (ce_task_desc_t *)hal_malloc(sizeof(ce_task_desc_t));
|
|||
|
|
if (task == NULL) {
|
|||
|
|
CE_ERR("hal_malloc fail\n");
|
|||
|
|
return NULL;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ce_task_desc_init(task, flow);
|
|||
|
|
hal_ce_method_set(dir, type, task);
|
|||
|
|
hal_ce_aes_mode_set(mode, task);
|
|||
|
|
hal_ce_key_set(key_buf, key_length, task);
|
|||
|
|
hal_dcache_clean((unsigned long)key_buf, key_length);
|
|||
|
|
|
|||
|
|
return task;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static uint32_t ce_aes_sw_padding(crypto_aes_req_ctx_t *ctx)
|
|||
|
|
{
|
|||
|
|
uint32_t blk_num = 0;
|
|||
|
|
uint32_t padding_size = 0;
|
|||
|
|
uint32_t last_blk_size = 0;
|
|||
|
|
|
|||
|
|
blk_num = ctx->src_length / AES_BLOCK_SIZE;
|
|||
|
|
last_blk_size = ctx->src_length % AES_BLOCK_SIZE;
|
|||
|
|
|
|||
|
|
if (last_blk_size) {
|
|||
|
|
padding_size = AES_BLOCK_SIZE - last_blk_size;
|
|||
|
|
memcpy(ctx->padding, ctx->src_buffer + blk_num * AES_BLOCK_SIZE, last_blk_size);
|
|||
|
|
memset(ctx->padding + last_blk_size, padding_size, padding_size);
|
|||
|
|
ctx->padding_len = AES_BLOCK_SIZE;
|
|||
|
|
} else {
|
|||
|
|
ctx->padding_len = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return blk_num * AES_BLOCK_SIZE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int ce_aes_start(crypto_aes_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
int ret = 0;
|
|||
|
|
ce_task_desc_t *task;
|
|||
|
|
uint32_t src_len = 0;
|
|||
|
|
uint32_t src_word_len = 0;
|
|||
|
|
|
|||
|
|
src_len = ce_aes_sw_padding(req_ctx);
|
|||
|
|
src_word_len = src_len >> 2;
|
|||
|
|
|
|||
|
|
/*ce task config*/
|
|||
|
|
|
|||
|
|
task = ce_aes_config(req_ctx->dir, CE_METHOD_AES, req_ctx->mode, req_ctx->key, req_ctx->key_length);
|
|||
|
|
if (task == NULL) {
|
|||
|
|
CE_ERR("ce_aes_config fail\n");
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
hal_ce_pending_clear(task->chan_id);
|
|||
|
|
|
|||
|
|
if (req_ctx->iv) {
|
|||
|
|
hal_ce_iv_set(req_ctx->iv, AES_BLOCK_SIZE, task);
|
|||
|
|
hal_dcache_clean((unsigned long)req_ctx->iv, AES_BLOCK_SIZE);
|
|||
|
|
}
|
|||
|
|
if (CE_AES_MODE_CTR == req_ctx->mode) {
|
|||
|
|
hal_ce_cnt_set(req_ctx->iv_next, req_ctx->key_length, task);
|
|||
|
|
hal_dcache_clean((unsigned long)req_ctx->iv_next, req_ctx->key_length);
|
|||
|
|
} else if (CE_AES_MODE_CTS == req_ctx->mode) {
|
|||
|
|
hal_ce_cts_last(task);
|
|||
|
|
} else if (CE_AES_MODE_CFB == req_ctx->mode) {
|
|||
|
|
hal_ce_cfb_bitwidth_set(req_ctx->bitwidth,task);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((task->sym_ctl & 0xF00) == (CE_AES_MODE_CTS << CE_SYM_CTL_OP_MODE_SHIFT))
|
|||
|
|
task->data_len = src_len + req_ctx->padding_len;
|
|||
|
|
else
|
|||
|
|
hal_ce_data_len_set(src_len + req_ctx->padding_len, task);
|
|||
|
|
|
|||
|
|
if (src_len) {
|
|||
|
|
task->src[0].addr = (uint32_t)__va_to_pa((unsigned long)req_ctx->src_buffer);
|
|||
|
|
task->src[0].len = src_word_len;
|
|||
|
|
|
|||
|
|
if (req_ctx->padding_len) {
|
|||
|
|
task->src[1].addr = (uint32_t)__va_to_pa((unsigned long)req_ctx->padding);
|
|||
|
|
task->src[1].len = req_ctx->padding_len >> 2;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
task->src[0].addr = (uint32_t)__va_to_pa((unsigned long)req_ctx->padding);
|
|||
|
|
task->src[0].len = req_ctx->padding_len >> 2;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
task->dst[0].addr = (uint32_t)__va_to_pa((unsigned long)req_ctx->dst_buffer);
|
|||
|
|
task->dst[0].len = (src_len + req_ctx->padding_len) >> 2;
|
|||
|
|
|
|||
|
|
task->next = 0;
|
|||
|
|
hal_dcache_clean((unsigned long)task, sizeof(ce_task_desc_t));
|
|||
|
|
if (src_len) {
|
|||
|
|
hal_dcache_clean((unsigned long)req_ctx->src_buffer, src_len);
|
|||
|
|
}
|
|||
|
|
if (req_ctx->padding_len) {
|
|||
|
|
hal_dcache_clean((unsigned long)req_ctx->padding, req_ctx->padding_len);
|
|||
|
|
}
|
|||
|
|
hal_dcache_clean((unsigned long)req_ctx->dst_buffer, src_len + req_ctx->padding_len);
|
|||
|
|
//ce_print_task_info(task);
|
|||
|
|
hal_ce_set_task((unsigned long)task);
|
|||
|
|
hal_ce_irq_enable(task->chan_id);
|
|||
|
|
hal_ce_ctrl_start();
|
|||
|
|
|
|||
|
|
#ifdef CE_NO_IRQ
|
|||
|
|
hal_ce_wait_finish(task->chan_id);
|
|||
|
|
hal_ce_pending_clear(task->chan_id);
|
|||
|
|
#else
|
|||
|
|
#if 1
|
|||
|
|
ret = hal_sem_timedwait(ce_sem, CE_WAIT_TIME);
|
|||
|
|
if (ret != 0) {
|
|||
|
|
CE_ERR("Timed out\n");
|
|||
|
|
hal_free(task);
|
|||
|
|
return HAL_AES_TIME_OUT;
|
|||
|
|
}
|
|||
|
|
#else
|
|||
|
|
rt_wqueue_wait(&ce_wqueue, 0, RT_WAITING_FOREVER);
|
|||
|
|
#endif
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
hal_dcache_invalidate((uint32_t)req_ctx->dst_buffer, src_len + req_ctx->padding_len);
|
|||
|
|
|
|||
|
|
hal_ce_irq_disable(task->chan_id);
|
|||
|
|
|
|||
|
|
if (hal_ce_get_erro() > 0) {
|
|||
|
|
CE_ERR("error\n");
|
|||
|
|
hal_ce_reg_printf();
|
|||
|
|
hal_free(task);
|
|||
|
|
return HAL_AES_CRYPTO_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
CE_DBG("do_aes_crypto sucess\n");
|
|||
|
|
hal_free(task);
|
|||
|
|
return HAL_AES_STATUS_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int ce_aes_check_ctx_vaild(crypto_aes_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
if (req_ctx == NULL) {
|
|||
|
|
CE_ERR("aes req_ctx is NULL\n");
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((req_ctx->src_buffer == NULL)
|
|||
|
|
|| (req_ctx->dst_buffer == NULL)
|
|||
|
|
|| (req_ctx->key == NULL)
|
|||
|
|
|| ((req_ctx->mode != CE_AES_MODE_ECB) && (req_ctx->iv == NULL) )) {
|
|||
|
|
CE_ERR("input is NULL\n");
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((req_ctx->key_length != AES_KEYSIZE_16)
|
|||
|
|
&& (req_ctx->key_length != AES_KEYSIZE_24)
|
|||
|
|
&& (req_ctx->key_length != AES_KEYSIZE_32)) {
|
|||
|
|
CE_ERR("key length is %ld, invalid\n", req_ctx->key_length);
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((((u32)req_ctx->src_buffer & (CE_ALIGN_SIZE - 1)) != 0)
|
|||
|
|
|| (((u32)req_ctx->dst_buffer & (CE_ALIGN_SIZE - 1)) != 0)
|
|||
|
|
|| (((u32)req_ctx->key & (CE_ALIGN_SIZE - 1)) != 0)) {
|
|||
|
|
CE_ERR("input buffer is not %d align\n", CE_ALIGN_SIZE);
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (req_ctx->dir == CE_DIR_DECRYPT) {
|
|||
|
|
if (((req_ctx->mode == CE_AES_MODE_ECB)
|
|||
|
|
|| (req_ctx->mode == CE_AES_MODE_CBC)
|
|||
|
|
|| (req_ctx->mode == CE_AES_MODE_CTS))
|
|||
|
|
&& (req_ctx->src_length % AES_BLOCK_SIZE != 0)) {
|
|||
|
|
CE_ERR("src_length: %d is not %d align\n",
|
|||
|
|
req_ctx->src_length, AES_BLOCK_SIZE);
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
if (req_ctx->src_length > req_ctx->dst_length) {
|
|||
|
|
CE_ERR("src_length: %d should not bigger than dst_length: %d\n",
|
|||
|
|
req_ctx->src_length, req_ctx->dst_length);
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else if (req_ctx->dir == CE_DIR_ENCRYPT) {
|
|||
|
|
if (req_ctx->dst_length < CE_ROUND_UP(req_ctx->src_length, AES_BLOCK_SIZE)) {
|
|||
|
|
CE_ERR("dst_length: %d should not smaller than %d\n",
|
|||
|
|
req_ctx->dst_length,
|
|||
|
|
CE_ROUND_UP(req_ctx->src_length, AES_BLOCK_SIZE));
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
CE_ERR("input crypt dir: %d is error.\n", req_ctx->dir);
|
|||
|
|
return HAL_AES_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return HAL_AES_STATUS_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int do_aes_crypto(crypto_aes_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
uint32_t last_block_size = 0;
|
|||
|
|
uint32_t block_num = 0;
|
|||
|
|
uint32_t padding_size = 0;
|
|||
|
|
uint32_t first_encypt_size = 0;
|
|||
|
|
uint8_t data_block[AES_BLOCK_SIZE] = {0};
|
|||
|
|
uint8_t *iv;
|
|||
|
|
uint8_t *init_vector2;
|
|||
|
|
ce_task_desc_t *task;
|
|||
|
|
int ret;
|
|||
|
|
|
|||
|
|
ret = ce_aes_check_ctx_vaild(req_ctx);
|
|||
|
|
if (ret) {
|
|||
|
|
CE_ERR("ce_aes_check_ctx_vaild fail\n");
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ret = ce_aes_start(req_ctx);
|
|||
|
|
if (ret < 0) {
|
|||
|
|
CE_ERR("aes crypto fail\n");
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static uint32_t ce_hash_endian4(uint32_t data)
|
|||
|
|
{
|
|||
|
|
uint32_t d1, d2, d3, d4;
|
|||
|
|
|
|||
|
|
d1 = (data & 0xff) << 24;
|
|||
|
|
d2 = (data & 0xff00) << 8;
|
|||
|
|
d3 = (data & 0xff0000) >> 8;
|
|||
|
|
d4 = (data & 0xff000000) >> 24;
|
|||
|
|
|
|||
|
|
return (d1 | d2 | d3 | d4);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static uint32_t ce_hash_blk_size(int type)
|
|||
|
|
{
|
|||
|
|
if ((type == CE_METHOD_SHA384) || (type == CE_METHOD_SHA512))
|
|||
|
|
return SHA512_BLOCK_SIZE;
|
|||
|
|
return SHA1_BLOCK_SIZE;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static uint32_t ce_hash_sw_padding(crypto_hash_req_ctx_t *ctx)
|
|||
|
|
{
|
|||
|
|
uint32_t blk_size = ce_hash_blk_size(ctx->type);
|
|||
|
|
uint32_t len_threshold = (blk_size == SHA512_BLOCK_SIZE) ? 112 : 56;
|
|||
|
|
uint32_t n = ctx->src_length % blk_size;
|
|||
|
|
uint8_t *p = ctx->padding;
|
|||
|
|
uint32_t len_l = ctx->src_length << 3; /* total len, in bits. */
|
|||
|
|
uint32_t len_h = ctx->src_length >> 29;
|
|||
|
|
uint32_t big_endian = (ctx->type == CE_METHOD_MD5) ? 0 : 1;
|
|||
|
|
|
|||
|
|
memset(ctx->padding, 0, 256);
|
|||
|
|
|
|||
|
|
if (n) {
|
|||
|
|
memcpy(ctx->padding, ctx->src_buffer + ctx->src_length - n, n);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
CE_DBG("ctx->type = %d, n = %d, ctx->src_length = %d\n", ctx->type, n, ctx->src_length);
|
|||
|
|
p[n] = 0x80;
|
|||
|
|
n++;
|
|||
|
|
|
|||
|
|
if (n > len_threshold) { /* The pad data need two blocks. */
|
|||
|
|
memset(p+n, 0, blk_size*2 - n);
|
|||
|
|
p += blk_size*2 - 8;
|
|||
|
|
} else {
|
|||
|
|
memset(p+n, 0, blk_size - n);
|
|||
|
|
p += blk_size - 8;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (big_endian == 1) {
|
|||
|
|
#if 0
|
|||
|
|
/* The length should use bit64 in SHA384/512 case.
|
|||
|
|
* The OpenSSL package is always small than 8K,
|
|||
|
|
* so we use still bit32.
|
|||
|
|
*/
|
|||
|
|
if (blk_size == SHA512_BLOCK_SIZE) {
|
|||
|
|
int len_hh = ctx->cnt >> 61;
|
|||
|
|
*(int *)(p-4) = ce_hash_endian4(len_hh);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
*(int *)p = ce_hash_endian4(len_h);
|
|||
|
|
*(int *)(p+4) = ce_hash_endian4(len_l);
|
|||
|
|
} else {
|
|||
|
|
*(int *)p = len_l;
|
|||
|
|
*(int *)(p+4) = len_h;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ctx->padding_len = (uint32_t)(p + 8 - ctx->padding);
|
|||
|
|
|
|||
|
|
CE_DBG("After padding %d: %02x %02x %02x %02x %02x %02x %02x %02x\n",
|
|||
|
|
ctx->padding_len,
|
|||
|
|
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
|
|||
|
|
|
|||
|
|
return ctx->src_length - (ctx->src_length % blk_size);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int ce_hash_start(crypto_hash_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
int ret = 0;
|
|||
|
|
int i = 0;
|
|||
|
|
uint8_t chan_id = 1;
|
|||
|
|
ce_task_desc_t *task = NULL;
|
|||
|
|
uint32_t src_word_len = 0;
|
|||
|
|
uint32_t src_length = ce_hash_sw_padding(req_ctx);
|
|||
|
|
|
|||
|
|
src_word_len = src_length >> 2;
|
|||
|
|
|
|||
|
|
task = (ce_task_desc_t *)hal_malloc(sizeof(ce_task_desc_t));
|
|||
|
|
if (task == NULL) {
|
|||
|
|
CE_ERR("hal_malloc fail\n");
|
|||
|
|
return HAL_HASH_MALLOC_ERROR;
|
|||
|
|
}
|
|||
|
|
CE_DBG("task addr = 0x%lx\n", (uint32_t)task);
|
|||
|
|
|
|||
|
|
ce_task_desc_init(task, chan_id);
|
|||
|
|
hal_ce_pending_clear(chan_id);
|
|||
|
|
hal_ce_method_set(req_ctx->dir, req_ctx->type, task);
|
|||
|
|
hal_ce_data_len_set(src_length + req_ctx->padding_len, task);
|
|||
|
|
if (req_ctx->md_size) {
|
|||
|
|
hal_ce_iv_set(req_ctx->md, req_ctx->md_size, task);
|
|||
|
|
hal_dcache_clean((unsigned long)req_ctx->md, req_ctx->md_size);
|
|||
|
|
hal_ce_iv_mode_set(CE_HASH_IV_INPUT, task);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (src_word_len != 0) {
|
|||
|
|
task->src[0].addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->src_buffer);
|
|||
|
|
task->src[0].len = src_word_len;
|
|||
|
|
task->src[1].addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->padding);
|
|||
|
|
task->src[1].len = req_ctx->padding_len >> 2;
|
|||
|
|
} else {
|
|||
|
|
task->src[0].addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->padding);
|
|||
|
|
task->src[0].len = req_ctx->padding_len >> 2;
|
|||
|
|
}
|
|||
|
|
task->dst[0].addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->dst_buffer);
|
|||
|
|
task->dst[0].len = req_ctx->dst_length >> 2;
|
|||
|
|
task->next = 0;
|
|||
|
|
|
|||
|
|
hal_dcache_clean((uint32_t)task, sizeof(ce_task_desc_t));
|
|||
|
|
hal_dcache_clean((uint32_t)req_ctx->src_buffer, req_ctx->src_length);
|
|||
|
|
hal_dcache_clean((uint32_t)req_ctx->padding, req_ctx->padding_len);
|
|||
|
|
hal_dcache_clean((uint32_t)req_ctx->dst_buffer, req_ctx->dst_length);
|
|||
|
|
//FlushCacheAll();
|
|||
|
|
//ce_print_task_info(task);
|
|||
|
|
hal_ce_set_task((uint32_t)task);
|
|||
|
|
hal_ce_irq_enable(task->chan_id);
|
|||
|
|
hal_ce_ctrl_start();
|
|||
|
|
|
|||
|
|
#ifdef CE_NO_IRQ
|
|||
|
|
hal_ce_wait_finish(task->chan_id);
|
|||
|
|
hal_ce_pending_clear(task->chan_id);
|
|||
|
|
#else
|
|||
|
|
ret = hal_sem_timedwait(ce_sem, CE_WAIT_TIME);
|
|||
|
|
if (ret != 0) {
|
|||
|
|
CE_ERR("Timed out\n");
|
|||
|
|
ret = HAL_HASH_TIME_OUT;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
hal_dcache_invalidate((uint32_t)req_ctx->dst_buffer, req_ctx->dst_length);
|
|||
|
|
|
|||
|
|
if (hal_ce_get_erro() > 0) {
|
|||
|
|
hal_ce_reg_printf();
|
|||
|
|
ret = HAL_HASH_CRYPTO_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
//ce_print_hex((char *)task->dst[0].addr, (task->dst[0].len * 4), (char *)task->dst[0].addr);
|
|||
|
|
//hal_ce_reg_printf();
|
|||
|
|
|
|||
|
|
hal_ce_irq_disable(task->chan_id);
|
|||
|
|
memcpy(req_ctx->md, req_ctx->dst_buffer, req_ctx->dst_length);
|
|||
|
|
req_ctx->md_size = req_ctx->dst_length;
|
|||
|
|
hal_free(task);
|
|||
|
|
|
|||
|
|
return HAL_HASH_STATUS_OK;
|
|||
|
|
|
|||
|
|
fail:
|
|||
|
|
if (task) {
|
|||
|
|
hal_free(task);
|
|||
|
|
}
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int ce_hash_check_ctx_valid(crypto_hash_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
if (req_ctx == NULL) {
|
|||
|
|
CE_ERR("sha req_ctx is NULL\n");
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((((u32)req_ctx->dst_buffer & (CE_ALIGN_SIZE - 1)) != 0)
|
|||
|
|
|| (((u32)req_ctx->src_buffer & (CE_ALIGN_SIZE - 1)) != 0)) {
|
|||
|
|
CE_ERR("input buffer addr is not %d align\n", CE_ALIGN_SIZE);
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (req_ctx->type == CE_METHOD_MD5) {
|
|||
|
|
if ((req_ctx->dst_length != MD5_DIGEST_SIZE)
|
|||
|
|
|| ((req_ctx->md_size != 0)
|
|||
|
|
&& (req_ctx->md_size != MD5_DIGEST_SIZE))) {
|
|||
|
|
CE_ERR("output length is not %d\n", MD5_DIGEST_SIZE);
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else if (req_ctx->type == CE_METHOD_SHA1) {
|
|||
|
|
if ((req_ctx->dst_length != SHA1_DIGEST_SIZE)
|
|||
|
|
|| ((req_ctx->md_size != 0)
|
|||
|
|
&& (req_ctx->md_size != SHA1_DIGEST_SIZE))) {
|
|||
|
|
CE_ERR("output length is not %d\n", SHA1_DIGEST_SIZE);
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else if (req_ctx->type == CE_METHOD_SHA224) {
|
|||
|
|
if ((req_ctx->dst_length != SHA256_DIGEST_SIZE)
|
|||
|
|
|| ((req_ctx->md_size != 0)
|
|||
|
|
&& (req_ctx->md_size != SHA256_DIGEST_SIZE))) {
|
|||
|
|
CE_ERR("output length is not %d\n", SHA256_DIGEST_SIZE);
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else if (req_ctx->type == CE_METHOD_SHA256) {
|
|||
|
|
if ((req_ctx->dst_length != SHA256_DIGEST_SIZE)
|
|||
|
|
|| ((req_ctx->md_size != 0)
|
|||
|
|
&& (req_ctx->md_size != SHA256_DIGEST_SIZE))) {
|
|||
|
|
CE_ERR("output length is not %d\n", SHA256_DIGEST_SIZE);
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else if (req_ctx->type == CE_METHOD_SHA384) {
|
|||
|
|
if ((req_ctx->dst_length != SHA512_DIGEST_SIZE)
|
|||
|
|
|| ((req_ctx->md_size != 0)
|
|||
|
|
&& (req_ctx->md_size != SHA512_DIGEST_SIZE))) {
|
|||
|
|
CE_ERR("output length is not %d\n", SHA512_DIGEST_SIZE);
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else if (req_ctx->type == CE_METHOD_SHA512) {
|
|||
|
|
if ((req_ctx->dst_length != SHA512_DIGEST_SIZE)
|
|||
|
|
|| ((req_ctx->md_size != 0)
|
|||
|
|
&& (req_ctx->md_size != SHA512_DIGEST_SIZE))) {
|
|||
|
|
CE_ERR("output length is not %d\n", SHA512_DIGEST_SIZE);
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
CE_ERR("ce don't support hash mode: %d\n", req_ctx->type);
|
|||
|
|
return HAL_HASH_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return HAL_HASH_STATUS_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int do_hash_crypto(crypto_hash_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
uint8_t *src_tmp = NULL;
|
|||
|
|
uint32_t src_align_len = 0;
|
|||
|
|
int ret = 0;
|
|||
|
|
|
|||
|
|
ret = ce_hash_check_ctx_valid(req_ctx);
|
|||
|
|
if (ret < 0) {
|
|||
|
|
CE_ERR("ce_hash_check_ctx_valid fail: %d\n", ret);
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ret = ce_hash_start(req_ctx);
|
|||
|
|
if (ret < 0) {
|
|||
|
|
CE_ERR("caclu hash erro num is %d\n", ret);
|
|||
|
|
return HAL_HASH_CRYPTO_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return HAL_HASH_STATUS_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void ce_rsa_sw_padding(uint8_t *dst_buf, uint8_t *src_buf, uint32_t data_len, uint32_t group_len)
|
|||
|
|
{
|
|||
|
|
int i = 0;
|
|||
|
|
|
|||
|
|
memset(dst_buf, 0, group_len);
|
|||
|
|
for (i = group_len - data_len; i < group_len; i++) {
|
|||
|
|
dst_buf[i] = src_buf[group_len - 1 - i];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int ce_rsa_start(crypto_rsa_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
int ret = 0;
|
|||
|
|
uint8_t chan_id = 2;
|
|||
|
|
uint8_t *p_src = NULL;
|
|||
|
|
uint8_t *p_n = NULL;
|
|||
|
|
uint8_t *p_d = NULL;
|
|||
|
|
uint8_t *p_dst = NULL;
|
|||
|
|
ce_task_desc_t *task = NULL;
|
|||
|
|
uint32_t bitwidth_byte_len = 0;
|
|||
|
|
uint32_t bitwidth_word_len = 0;
|
|||
|
|
|
|||
|
|
bitwidth_byte_len = req_ctx->bitwidth >> 3;
|
|||
|
|
bitwidth_word_len = req_ctx->bitwidth >> 5;
|
|||
|
|
|
|||
|
|
p_src = hal_malloc(bitwidth_byte_len);
|
|||
|
|
if (p_src == NULL) {
|
|||
|
|
CE_ERR("rsa src hal_malloc fail\n");
|
|||
|
|
ret = HAL_RSA_MALLOC_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
memset(p_src, 0x0, bitwidth_byte_len);
|
|||
|
|
ce_rsa_sw_padding(p_src, req_ctx->src_buffer, req_ctx->src_length, bitwidth_byte_len);
|
|||
|
|
|
|||
|
|
p_n = hal_malloc(bitwidth_byte_len);
|
|||
|
|
if (p_n == NULL) {
|
|||
|
|
CE_ERR("rsa key n hal_malloc fail\n");
|
|||
|
|
ret = HAL_RSA_MALLOC_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
memset(p_n, 0x0, bitwidth_byte_len);
|
|||
|
|
ce_rsa_sw_padding(p_n, req_ctx->key_n, req_ctx->n_len, bitwidth_byte_len);
|
|||
|
|
|
|||
|
|
if (req_ctx->key_d) {
|
|||
|
|
p_d = hal_malloc(bitwidth_byte_len);
|
|||
|
|
if (p_d == NULL) {
|
|||
|
|
CE_ERR("rsa key d hal_malloc fail\n");
|
|||
|
|
ret = HAL_RSA_MALLOC_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
memset(p_d, 0x0, bitwidth_byte_len);
|
|||
|
|
ce_rsa_sw_padding(p_d, req_ctx->key_d, req_ctx->d_len, bitwidth_byte_len);
|
|||
|
|
req_ctx->key_d = p_d;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
p_dst = hal_malloc(bitwidth_byte_len);
|
|||
|
|
if (p_dst == NULL) {
|
|||
|
|
CE_ERR("hal_malloc fail\n");
|
|||
|
|
ret = HAL_RSA_MALLOC_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
memset(p_dst, 0x0, bitwidth_byte_len);
|
|||
|
|
|
|||
|
|
task = (ce_task_desc_t *)hal_malloc(sizeof(ce_task_desc_t));
|
|||
|
|
if (task == NULL) {
|
|||
|
|
CE_ERR("rt_malloc_align fail\n");
|
|||
|
|
ret = HAL_RSA_MALLOC_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
CE_DBG("task addr = 0x%lx\n", (uint32_t)task);
|
|||
|
|
|
|||
|
|
ce_task_desc_init(task, chan_id);
|
|||
|
|
hal_ce_pending_clear(chan_id);
|
|||
|
|
hal_ce_method_set(req_ctx->dir, req_ctx->type, task);
|
|||
|
|
hal_ce_rsa_width_set(req_ctx->bitwidth, task);
|
|||
|
|
task->iv_addr = (uint32_t)__va_to_pa((uint32_t)p_n);
|
|||
|
|
if (req_ctx->key_d)
|
|||
|
|
task->key_addr = (uint32_t)__va_to_pa((uint32_t)p_d);
|
|||
|
|
else
|
|||
|
|
task->key_addr = (uint32_t)__va_to_pa((uint32_t)req_ctx->key_e);
|
|||
|
|
|
|||
|
|
hal_ce_data_len_set(bitwidth_byte_len, task);
|
|||
|
|
|
|||
|
|
task->src[0].addr = (uint32_t)__va_to_pa((uint32_t)p_src);
|
|||
|
|
task->src[0].len = bitwidth_word_len;
|
|||
|
|
|
|||
|
|
task->dst[0].addr = (uint32_t)__va_to_pa((uint32_t)p_dst);
|
|||
|
|
task->dst[0].len = bitwidth_word_len;
|
|||
|
|
task->next = 0;
|
|||
|
|
|
|||
|
|
hal_dcache_clean((uint32_t)task, sizeof(ce_task_desc_t));
|
|||
|
|
hal_dcache_clean((uint32_t)p_src, bitwidth_byte_len);
|
|||
|
|
hal_dcache_clean((uint32_t)p_n, bitwidth_byte_len);
|
|||
|
|
if (req_ctx->key_d)
|
|||
|
|
hal_dcache_clean((uint32_t)p_d, bitwidth_byte_len);
|
|||
|
|
else
|
|||
|
|
hal_dcache_clean((uint32_t)req_ctx->key_e, bitwidth_byte_len);
|
|||
|
|
hal_dcache_clean((uint32_t)p_dst, bitwidth_byte_len);
|
|||
|
|
|
|||
|
|
//FlushCacheAll();
|
|||
|
|
/*ce_print_task_info(task);*/
|
|||
|
|
hal_ce_set_task((uint32_t)task);
|
|||
|
|
hal_ce_irq_enable(task->chan_id);
|
|||
|
|
hal_ce_ctrl_start();
|
|||
|
|
|
|||
|
|
#ifdef CE_NO_IRQ
|
|||
|
|
hal_ce_wait_finish(task->chan_id);
|
|||
|
|
hal_ce_pending_clear(task->chan_id);
|
|||
|
|
#else
|
|||
|
|
ret = hal_sem_timedwait(ce_sem, CE_WAIT_TIME);
|
|||
|
|
if (ret != 0) {
|
|||
|
|
CE_ERR("Timed out\n");
|
|||
|
|
ret = HAL_RSA_CRYPTO_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
hal_dcache_invalidate((uint32_t)p_dst, bitwidth_byte_len);
|
|||
|
|
|
|||
|
|
/*ce_reg_printf();*/
|
|||
|
|
if (hal_ce_get_erro() > 0) {
|
|||
|
|
hal_ce_reg_printf();
|
|||
|
|
ret = HAL_RSA_CRYPTO_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
hal_ce_irq_disable(task->chan_id);
|
|||
|
|
|
|||
|
|
ce_rsa_sw_padding(req_ctx->dst_buffer, p_dst, req_ctx->dst_length, req_ctx->dst_length);
|
|||
|
|
|
|||
|
|
fail:
|
|||
|
|
if (p_src)
|
|||
|
|
hal_free(p_src);
|
|||
|
|
|
|||
|
|
if (p_n)
|
|||
|
|
hal_free(p_n);
|
|||
|
|
|
|||
|
|
if (p_d)
|
|||
|
|
hal_free(p_d);
|
|||
|
|
|
|||
|
|
if (p_dst)
|
|||
|
|
hal_free(p_dst);
|
|||
|
|
|
|||
|
|
if (task)
|
|||
|
|
hal_free(task);
|
|||
|
|
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int ce_rsa_check_ctx_valid(crypto_rsa_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
if (req_ctx == NULL) {
|
|||
|
|
CE_ERR("rsa req_ctx is NULL\n");
|
|||
|
|
return HAL_RSA_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((((u32)req_ctx->key_n & (CE_ALIGN_SIZE - 1)) != 0)
|
|||
|
|
|| (((u32)req_ctx->key_e & (CE_ALIGN_SIZE - 1)) != 0)
|
|||
|
|
|| (((u32)req_ctx->key_d & (CE_ALIGN_SIZE - 1)) != 0)
|
|||
|
|
|| (((u32)req_ctx->src_buffer & (CE_ALIGN_SIZE - 1)) != 0)
|
|||
|
|
|| (((u32)req_ctx->dst_buffer & (CE_ALIGN_SIZE - 1)) != 0)) {
|
|||
|
|
printf("rsa req_ctx buffer is not %d align\n", CE_ALIGN_SIZE);
|
|||
|
|
return HAL_RSA_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((req_ctx->bitwidth == 512)
|
|||
|
|
|| (req_ctx->bitwidth == 1024)
|
|||
|
|
|| (req_ctx->bitwidth == 2048)) {
|
|||
|
|
if ((req_ctx->n_len > req_ctx->bitwidth / 8)
|
|||
|
|
|| (req_ctx->e_len > req_ctx->bitwidth / 8)
|
|||
|
|
|| (req_ctx->d_len > req_ctx->bitwidth / 8)
|
|||
|
|
|| (req_ctx->src_length > req_ctx->bitwidth / 8)
|
|||
|
|
|| (req_ctx->dst_length > req_ctx->bitwidth / 8)) {
|
|||
|
|
CE_ERR("rsa length should not bigger than %d\n", req_ctx->bitwidth / 8);
|
|||
|
|
return HAL_RSA_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
CE_ERR("invalid bitwidth: %d\n", req_ctx->bitwidth);
|
|||
|
|
return HAL_RSA_INPUT_ERROR;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return HAL_RSA_STATUS_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int do_rsa_crypto(crypto_rsa_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
int ret = 0;
|
|||
|
|
|
|||
|
|
ret = ce_rsa_check_ctx_valid(req_ctx);
|
|||
|
|
if (ret < 0) {
|
|||
|
|
CE_ERR("ce_rsa_check_ctx_valid fail: %d\n", ret);
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ret = ce_rsa_start(req_ctx);
|
|||
|
|
if (ret < 0) {
|
|||
|
|
CE_ERR("calc rsa erro num is %d\n", ret);
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return HAL_RSA_STATUS_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int do_rng_gen(crypto_rng_req_ctx_t *req_ctx)
|
|||
|
|
{
|
|||
|
|
int ret = 0;
|
|||
|
|
uint8_t chan_id = 2;
|
|||
|
|
uint32_t dst_len = 0;
|
|||
|
|
uint8_t *dst_buf = NULL;
|
|||
|
|
ce_task_desc_t *task = NULL;
|
|||
|
|
|
|||
|
|
if (req_ctx->mode == CE_METHOD_TRNG) {
|
|||
|
|
dst_len = CE_ROUND_UP(req_ctx->rng_len, 32); /*align with 32 Bytes*/
|
|||
|
|
} else if (req_ctx->mode == CE_METHOD_PRNG) {
|
|||
|
|
dst_len = CE_ROUND_UP(req_ctx->rng_len, 20); /*align with 20 Bytes*/
|
|||
|
|
} else {
|
|||
|
|
CE_ERR("Error: do not support mode %d\n", req_ctx->mode);
|
|||
|
|
ret = HAL_RNG_INPUT_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (dst_len > SS_RNG_MAX_LEN) {
|
|||
|
|
CE_ERR("Error: The RNG length is too large: %d\n", dst_len);
|
|||
|
|
ret = HAL_RNG_INPUT_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
dst_buf = (uint8_t *)hal_malloc(dst_len);
|
|||
|
|
if (dst_buf == NULL) {
|
|||
|
|
CE_ERR("hal_malloc dst_buf fail\n");
|
|||
|
|
ret = HAL_RNG_MALLOC_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
task = (ce_task_desc_t *)hal_malloc(sizeof(ce_task_desc_t));
|
|||
|
|
if (task == NULL) {
|
|||
|
|
CE_ERR("hal_malloc task fail\n");
|
|||
|
|
ret = HAL_RNG_MALLOC_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
CE_DBG("task addr = 0x%lx, rng_buf = 0x%lx, rng_len = %d\n", (uint32_t)task, req_ctx->rng_buf, req_ctx->rng_len);
|
|||
|
|
|
|||
|
|
ce_task_desc_init(task, chan_id);
|
|||
|
|
hal_ce_pending_clear(chan_id);
|
|||
|
|
hal_ce_method_set(0, req_ctx->mode, task);
|
|||
|
|
hal_ce_data_len_set(dst_len, task);
|
|||
|
|
|
|||
|
|
if (req_ctx->mode == CE_METHOD_PRNG) {
|
|||
|
|
/* must set the seed add in prng */
|
|||
|
|
if (req_ctx->key && (req_ctx->key_len == 24)) {
|
|||
|
|
hal_ce_key_set(req_ctx->key, req_ctx->key_len, task);
|
|||
|
|
hal_dcache_clean((uint32_t)req_ctx->key, req_ctx->key_len);
|
|||
|
|
} else {
|
|||
|
|
CE_ERR("Error: RRNG must set seed, and the seed size must be 24!\n");
|
|||
|
|
ret = HAL_RNG_INPUT_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
task->src[0].addr = 0;
|
|||
|
|
task->src[0].len = 0;
|
|||
|
|
|
|||
|
|
task->dst[0].addr = (uint32_t)__va_to_pa((uint32_t)dst_buf);
|
|||
|
|
task->dst[0].len = dst_len >> 2;
|
|||
|
|
|
|||
|
|
hal_dcache_clean((uint32_t)task, sizeof(ce_task_desc_t));
|
|||
|
|
hal_dcache_clean((uint32_t)dst_buf, dst_len);
|
|||
|
|
|
|||
|
|
//ce_print_task_info(task);
|
|||
|
|
hal_ce_set_task((uint32_t)task);
|
|||
|
|
hal_ce_irq_enable(task->chan_id);
|
|||
|
|
hal_ce_ctrl_start();
|
|||
|
|
|
|||
|
|
#ifdef CE_NO_IRQ
|
|||
|
|
hal_ce_wait_finish(task->chan_id);
|
|||
|
|
hal_ce_pending_clear(task->chan_id);
|
|||
|
|
#else
|
|||
|
|
ret = hal_sem_timedwait(ce_sem, CE_WAIT_TIME);
|
|||
|
|
if (ret != 0) {
|
|||
|
|
CE_ERR("Timed out\n");
|
|||
|
|
ret = HAL_RNG_TIME_OUT;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
hal_dcache_invalidate((uint32_t)dst_buf, dst_len);
|
|||
|
|
|
|||
|
|
if (req_ctx->mode == CE_METHOD_PRNG) {
|
|||
|
|
hal_dcache_invalidate((uint32_t)req_ctx->key, req_ctx->key_len);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (hal_ce_get_erro() > 0) {
|
|||
|
|
hal_ce_reg_printf();
|
|||
|
|
ret = HAL_RNG_CRYPTO_ERROR;
|
|||
|
|
goto fail;
|
|||
|
|
}
|
|||
|
|
//ce_print_hex((char *)task->dst[0].addr, (task->dst[0].len * 4), (char *)task->dst[0].addr);
|
|||
|
|
/*ce_reg_printf();*/
|
|||
|
|
|
|||
|
|
memcpy(req_ctx->rng_buf, dst_buf, req_ctx->rng_len);
|
|||
|
|
|
|||
|
|
hal_ce_irq_disable(task->chan_id);
|
|||
|
|
|
|||
|
|
hal_free(task);
|
|||
|
|
hal_free(dst_buf);
|
|||
|
|
return HAL_RNG_STATUS_OK;
|
|||
|
|
|
|||
|
|
fail:
|
|||
|
|
if (task) {
|
|||
|
|
hal_free(task);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (dst_buf) {
|
|||
|
|
hal_free(task);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return ret;
|
|||
|
|
}
|