826 lines
21 KiB
C
Executable File
826 lines
21 KiB
C
Executable File
/*
|
|
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the
|
|
* distribution.
|
|
* 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of
|
|
* its contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS 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 "cmd_util.h"
|
|
#include "cmd_ce.h"
|
|
#include "driver/chip/hal_crypto.h"
|
|
#if (CONFIG_CHIP_ARCH_VER > 1)
|
|
#include "driver/chip/hal_trng.h"
|
|
#endif
|
|
#define CE_PLAIN_MAX_LEN 1024
|
|
#define CE_CIPHER_MAX_LEN (CE_PLAIN_MAX_LEN << 2)
|
|
|
|
static void cipher_str_to_arr(char *cipher_str, uint8_t *cipher_buf)
|
|
{
|
|
for (int i = 0; i < cmd_strlen(cipher_str); i += 2) {
|
|
if (cipher_str[i] <= '9') {
|
|
cipher_buf[i >> 1] = (cipher_str[i] - '0') << 4;
|
|
} else if (cipher_str[i] <= 'F') {
|
|
cipher_buf[i >> 1] = (cipher_str[i] - 55) << 4;
|
|
} else {
|
|
cipher_buf[i >> 1] = (cipher_str[i] - 87) << 4;
|
|
}
|
|
|
|
if (cipher_str[i + 1] <= '9') {
|
|
cipher_buf[i >> 1] += cipher_str[i + 1] - '0';
|
|
} else if (cipher_str[i + 1] <= 'F') {
|
|
cipher_buf[i >> 1] += cipher_str[i + 1] - 55;
|
|
} else {
|
|
cipher_buf[i >> 1] += cipher_str[i + 1] - 87;
|
|
}
|
|
}
|
|
}
|
|
|
|
static enum cmd_status cmd_encrypto_aes_exec(char *cmd)
|
|
{
|
|
int32_t cnt;
|
|
char mode_str[8];
|
|
char key_str[33];
|
|
char *plain_str;
|
|
uint8_t *cipher_buf;
|
|
int8_t key_len = 0;
|
|
uint32_t plain_len = 0;
|
|
uint32_t cipher_len = 0;
|
|
CE_AES_Config aes_cfg;
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
|
|
plain_str = (char *)cmd_malloc(CE_PLAIN_MAX_LEN);
|
|
if (plain_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "m=%7s k=%s p=%s", mode_str, key_str, plain_str);
|
|
|
|
/* check param */
|
|
if (cnt != 3) {
|
|
CMD_ERR("invalid param number %d\n", cnt);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
memset(&aes_cfg, 0, sizeof(aes_cfg));
|
|
if (cmd_strcmp(mode_str, "ecb") == 0) {
|
|
aes_cfg.mode = CE_CRYPT_MODE_ECB;
|
|
} else if (cmd_strcmp(mode_str, "cbc") == 0) {
|
|
aes_cfg.mode = CE_CRYPT_MODE_CBC;
|
|
} else {
|
|
CMD_ERR("invalid mode %s\n", mode_str);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
|
|
key_len = cmd_strlen(key_str);
|
|
if (16 == key_len) {
|
|
aes_cfg.keysize = CE_CTL_AES_KEYSIZE_128BITS;
|
|
} else if (24 == key_len) {
|
|
aes_cfg.keysize = CE_CTL_AES_KEYSIZE_192BITS;
|
|
} else if (32 == key_len) {
|
|
aes_cfg.keysize = CE_CTL_AES_KEYSIZE_256BITS;
|
|
} else {
|
|
CMD_ERR("invalid param: key len %d != (16/24/32)\n", key_len);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
aes_cfg.src = CE_CTL_KEYSOURCE_INPUT;
|
|
sprintf((char *)aes_cfg.key, key_str);
|
|
|
|
plain_len = cmd_strlen(plain_str);
|
|
cipher_len = (plain_len + 15) & (~0xF);
|
|
cipher_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
if (HAL_AES_Encrypt(&aes_cfg, (uint8_t *)plain_str, (uint8_t *)cipher_buf, plain_len) != HAL_OK) {
|
|
CMD_ERR("AES encrypt failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_cipher;
|
|
}
|
|
printf("ciphertest(hex):");
|
|
cmd_print_uint8_array((uint8_t *)cipher_buf, cipher_len);
|
|
|
|
out_cipher:
|
|
cmd_free(cipher_buf);
|
|
out_plain:
|
|
cmd_free(plain_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_decrypto_aes_exec(char *cmd)
|
|
{
|
|
int32_t cnt;
|
|
char mode_str[8];
|
|
char key_str[33];
|
|
char *cipher_str;
|
|
uint8_t *plain_buf;
|
|
uint8_t *cipher_buf;
|
|
int8_t key_len = 0;
|
|
uint32_t cipher_len = 0;
|
|
CE_AES_Config aes_cfg;
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
|
|
cipher_str = (char *)cmd_malloc(CE_CIPHER_MAX_LEN);
|
|
if (cipher_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_cipher;
|
|
}
|
|
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "m=%7s k=%s c=%s", mode_str, key_str, cipher_str);
|
|
|
|
/* check param */
|
|
if (cnt != 3) {
|
|
CMD_ERR("invalid param number %d\n", cnt);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
memset(&aes_cfg, 0, sizeof(aes_cfg));
|
|
if (cmd_strcmp(mode_str, "ecb") == 0) {
|
|
aes_cfg.mode = CE_CRYPT_MODE_ECB;
|
|
} else if (cmd_strcmp(mode_str, "cbc") == 0) {
|
|
aes_cfg.mode = CE_CRYPT_MODE_CBC;
|
|
} else {
|
|
CMD_ERR("invalid mode %s\n", mode_str);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
|
|
key_len = cmd_strlen(key_str);
|
|
if (16 == key_len) {
|
|
aes_cfg.keysize = CE_CTL_AES_KEYSIZE_128BITS;
|
|
} else if (24 == key_len) {
|
|
aes_cfg.keysize = CE_CTL_AES_KEYSIZE_192BITS;
|
|
} else if (32 == key_len) {
|
|
aes_cfg.keysize = CE_CTL_AES_KEYSIZE_256BITS;
|
|
} else {
|
|
CMD_ERR("invalid param: key len %d != (16/24/32)\n", key_len);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
aes_cfg.src = CE_CTL_KEYSOURCE_INPUT;
|
|
sprintf((char *)aes_cfg.key, key_str);
|
|
|
|
cipher_len = cmd_strlen(cipher_str);
|
|
if ((cipher_len & 0xF) != 0) {
|
|
CMD_ERR("invalid param: cipher len %d != (16*n)\n", cipher_len);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
cipher_len = cipher_len >> 1;
|
|
cipher_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
cipher_str_to_arr(cipher_str, cipher_buf);
|
|
plain_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
if (HAL_AES_Decrypt(&aes_cfg, (uint8_t *)cipher_buf, (uint8_t *)plain_buf, cipher_len) != HAL_OK) {
|
|
CMD_ERR("AES encrypt failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
printf("plaintest:");
|
|
cmd_raw_mode_enable();
|
|
cmd_raw_mode_write(plain_buf, cipher_len);
|
|
cmd_raw_mode_disable();
|
|
printf("\n\n");
|
|
|
|
out_plain:
|
|
cmd_free(cipher_buf);
|
|
cmd_free(plain_buf);
|
|
out_cipher:
|
|
cmd_free(cipher_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_encrypto_des_exec(char *cmd)
|
|
{
|
|
int32_t cnt;
|
|
char mode_str[8];
|
|
char key_str[33];
|
|
char *plain_str = NULL;
|
|
uint8_t *cipher_buf;
|
|
int8_t key_len = 0;
|
|
uint32_t plain_len = 0;
|
|
uint32_t cipher_len = 0;
|
|
CE_DES_Config des_cfg;
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
|
|
plain_str = (char *)cmd_malloc(CE_PLAIN_MAX_LEN);
|
|
if (plain_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
memset(plain_str, 0, CE_PLAIN_MAX_LEN);
|
|
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "m=%7s k=%s p=%s", mode_str, key_str, plain_str);
|
|
/* check param */
|
|
if (cnt != 3) {
|
|
CMD_ERR("invalid param number %d\n", cnt);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
memset(&des_cfg, 0, sizeof(des_cfg));
|
|
if (cmd_strcmp(mode_str, "ecb") == 0) {
|
|
des_cfg.mode = CE_CRYPT_MODE_ECB;
|
|
} else if (cmd_strcmp(mode_str, "cbc") == 0) {
|
|
des_cfg.mode = CE_CRYPT_MODE_CBC;
|
|
} else {
|
|
CMD_ERR("invalid mode %s\n", mode_str);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
|
|
key_len = cmd_strlen(key_str);
|
|
if (8 != key_len) {
|
|
CMD_ERR("invalid param: key len %d != 8\n", key_len);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
des_cfg.src = CE_CTL_KEYSOURCE_INPUT;
|
|
sprintf((char *)des_cfg.key, key_str);
|
|
|
|
plain_len = cmd_strlen(plain_str);
|
|
plain_len = plain_len > 8 ? plain_len : 8;
|
|
cipher_len = (plain_len + 7) & (~0x7);
|
|
cipher_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
if (HAL_DES_Encrypt(&des_cfg, (uint8_t *)plain_str, (uint8_t *)cipher_buf, plain_len) != HAL_OK) {
|
|
CMD_ERR("DES encrypt failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_cipher;
|
|
}
|
|
printf("ciphertest(hex):");
|
|
cmd_print_uint8_array((uint8_t *)cipher_buf, cipher_len);
|
|
|
|
out_cipher:
|
|
cmd_free(cipher_buf);
|
|
out_plain:
|
|
cmd_free(plain_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_decrypto_des_exec(char *cmd)
|
|
{
|
|
int32_t cnt;
|
|
char mode_str[8];
|
|
char key_str[33];
|
|
char *cipher_str;
|
|
uint8_t *plain_buf;
|
|
uint8_t *cipher_buf;
|
|
int8_t key_len = 0;
|
|
uint32_t cipher_len = 0;
|
|
CE_DES_Config des_cfg;
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
|
|
cipher_str = (char *)cmd_malloc(CE_CIPHER_MAX_LEN);
|
|
if (cipher_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_cipher;
|
|
}
|
|
memset(cipher_str, 0, CE_CIPHER_MAX_LEN);
|
|
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "m=%7s k=%s c=%s", mode_str, key_str, cipher_str);
|
|
|
|
/* check param */
|
|
if (cnt != 3) {
|
|
CMD_ERR("invalid param number %d\n", cnt);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
memset(&des_cfg, 0, sizeof(des_cfg));
|
|
if (cmd_strcmp(mode_str, "ecb") == 0) {
|
|
des_cfg.mode = CE_CRYPT_MODE_ECB;
|
|
} else if (cmd_strcmp(mode_str, "cbc") == 0) {
|
|
des_cfg.mode = CE_CRYPT_MODE_CBC;
|
|
} else {
|
|
CMD_ERR("invalid mode %s\n", mode_str);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
|
|
key_len = cmd_strlen(key_str);
|
|
if (8 != key_len) {
|
|
CMD_ERR("invalid param: key len %d != 8\n", key_len);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
des_cfg.src = CE_CTL_KEYSOURCE_INPUT;
|
|
sprintf((char *)des_cfg.key, key_str);
|
|
|
|
cipher_len = cmd_strlen(cipher_str);
|
|
cipher_len = cipher_len >> 1;
|
|
cipher_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
cipher_str_to_arr(cipher_str, cipher_buf);
|
|
plain_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
if (HAL_DES_Decrypt(&des_cfg, (uint8_t *)cipher_buf, (uint8_t *)plain_buf, cipher_len) != HAL_OK) {
|
|
CMD_ERR("DES encrypt failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
printf("plaintest:");
|
|
cmd_raw_mode_enable();
|
|
cmd_raw_mode_write(plain_buf, cipher_len);
|
|
cmd_raw_mode_disable();
|
|
printf("\n\n");
|
|
|
|
out_plain:
|
|
cmd_free(cipher_buf);
|
|
cmd_free(plain_buf);
|
|
out_cipher:
|
|
cmd_free(cipher_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_encrypto_3des_exec(char *cmd)
|
|
{
|
|
int32_t cnt;
|
|
char mode_str[8];
|
|
char key_str[33];
|
|
char *plain_str;
|
|
uint8_t *cipher_buf;
|
|
int8_t key_len = 0;
|
|
uint32_t plain_len = 0;
|
|
uint32_t cipher_len = 0;
|
|
CE_3DES_Config des_cfg;
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
|
|
plain_str = (char *)cmd_malloc(CE_PLAIN_MAX_LEN);
|
|
if (plain_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
memset(plain_str, 0, CE_PLAIN_MAX_LEN);
|
|
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "m=%7s k=%s p=%s", mode_str, key_str, plain_str);
|
|
|
|
/* check param */
|
|
if (cnt != 3) {
|
|
CMD_ERR("invalid param number %d\n", cnt);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
memset(&des_cfg, 0, sizeof(des_cfg));
|
|
if (cmd_strcmp(mode_str, "ecb") == 0) {
|
|
des_cfg.mode = CE_CRYPT_MODE_ECB;
|
|
} else if (cmd_strcmp(mode_str, "cbc") == 0) {
|
|
des_cfg.mode = CE_CRYPT_MODE_CBC;
|
|
} else {
|
|
CMD_ERR("invalid mode %s\n", mode_str);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
|
|
key_len = cmd_strlen(key_str);
|
|
if (24 != key_len) {
|
|
CMD_ERR("invalid param: key len %d != 24\n", key_len);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
des_cfg.src = CE_CTL_KEYSOURCE_INPUT;
|
|
sprintf((char *)des_cfg.key, key_str);
|
|
|
|
plain_len = cmd_strlen(plain_str);
|
|
plain_len = plain_len > 8 ? plain_len : 8;
|
|
cipher_len = (plain_len + 7) & (~0x7);
|
|
cipher_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
if (HAL_3DES_Encrypt(&des_cfg, (uint8_t *)plain_str, (uint8_t *)cipher_buf, plain_len) != HAL_OK) {
|
|
CMD_ERR("3DES encrypt failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_cipher;
|
|
}
|
|
printf("ciphertest(hex):");
|
|
cmd_print_uint8_array((uint8_t *)cipher_buf, cipher_len);
|
|
|
|
out_cipher:
|
|
cmd_free(cipher_buf);
|
|
out_plain:
|
|
cmd_free(plain_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_decrypto_3des_exec(char *cmd)
|
|
{
|
|
int32_t cnt;
|
|
char mode_str[8];
|
|
char key_str[25];
|
|
char *cipher_str;
|
|
uint8_t *plain_buf;
|
|
uint8_t *cipher_buf;
|
|
int8_t key_len = 0;
|
|
uint32_t cipher_len = 0;
|
|
CE_3DES_Config des_cfg;
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
|
|
cipher_str = (char *)cmd_malloc(CE_CIPHER_MAX_LEN);
|
|
if (cipher_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_cipher;
|
|
}
|
|
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "m=%7s k=%s c=%s", mode_str, key_str, cipher_str);
|
|
|
|
/* check param */
|
|
if (cnt != 3) {
|
|
CMD_ERR("invalid param number %d\n", cnt);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
memset(&des_cfg, 0, sizeof(des_cfg));
|
|
if (cmd_strcmp(mode_str, "ecb") == 0) {
|
|
des_cfg.mode = CE_CRYPT_MODE_ECB;
|
|
} else if (cmd_strcmp(mode_str, "cbc") == 0) {
|
|
des_cfg.mode = CE_CRYPT_MODE_CBC;
|
|
} else {
|
|
CMD_ERR("invalid mode %s\n", mode_str);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
|
|
key_len = cmd_strlen(key_str);
|
|
if (24 != key_len) {
|
|
CMD_ERR("invalid param: key len %d != 24\n", key_len);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_cipher;
|
|
}
|
|
des_cfg.src = CE_CTL_KEYSOURCE_INPUT;
|
|
memcpy(des_cfg.key, key_str, key_len);
|
|
cipher_len = cmd_strlen(cipher_str);
|
|
cipher_len = cipher_len >> 1;
|
|
cipher_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
cipher_str_to_arr(cipher_str, cipher_buf);
|
|
plain_buf = (uint8_t *)cmd_malloc(cipher_len);
|
|
if (HAL_3DES_Decrypt(&des_cfg, (uint8_t *)cipher_buf, (uint8_t *)plain_buf, cipher_len) != HAL_OK) {
|
|
CMD_ERR("3DES encrypt failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
printf("plaintest:");
|
|
cmd_raw_mode_enable();
|
|
cmd_raw_mode_write(plain_buf, cipher_len);
|
|
cmd_raw_mode_disable();
|
|
printf("\n\n");
|
|
|
|
out_plain:
|
|
cmd_free(cipher_buf);
|
|
cmd_free(plain_buf);
|
|
out_cipher:
|
|
cmd_free(cipher_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_encrypto_crc_exec(char *cmd)
|
|
{
|
|
char type_str[17];
|
|
char *plain_str = NULL;
|
|
int plain_len = 0;
|
|
CE_CRC_Types type;
|
|
CE_CRC_Handler crc;
|
|
uint32_t res;
|
|
int32_t cnt;
|
|
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
|
|
plain_str = (char *)cmd_malloc(CE_PLAIN_MAX_LEN);
|
|
if (plain_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "t=%16s p=%s", type_str, plain_str);
|
|
/* check param */
|
|
if (cnt != 2) {
|
|
CMD_ERR("invalid param number %s\n", cmd);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
|
|
/* check param */
|
|
if (cmd_strcmp(type_str, "ibm") == 0) {
|
|
type = CE_CRC16_IBM;
|
|
} else if (cmd_strcmp(type_str, "maxim") == 0) {
|
|
type = CE_CRC16_MAXIM;
|
|
} else if (cmd_strcmp(type_str, "usb") == 0) {
|
|
type = CE_CRC16_USB;
|
|
} else if (cmd_strcmp(type_str, "modbus") == 0) {
|
|
type = CE_CRC16_MODBUS;
|
|
} else if (cmd_strcmp(type_str, "ccitt_1") == 0) {
|
|
type = CE_CRC16_CCITT_1;
|
|
} else if (cmd_strcmp(type_str, "ccitt") == 0) {
|
|
type = CE_CRC16_CCITT;
|
|
} else if (cmd_strcmp(type_str, "x25") == 0) {
|
|
type = CE_CRC16_X25;
|
|
} else if (cmd_strcmp(type_str, "xmodem") == 0) {
|
|
type = CE_CRC16_XMODEM;
|
|
} else if (cmd_strcmp(type_str, "dnp") == 0) {
|
|
type = CE_CRC16_DNP;
|
|
} else if (cmd_strcmp(type_str, "crc32") == 0) {
|
|
type = CE_CRC32;
|
|
} else if (cmd_strcmp(type_str, "mpeg2") == 0) {
|
|
type = CE_CRC32_MPEG2;
|
|
} else {
|
|
CMD_ERR("invalid type %s\n", type_str);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
plain_len = cmd_strlen(plain_str);
|
|
if (HAL_CRC_Init(&crc, type, plain_len) != HAL_OK) {
|
|
CMD_ERR("crc init failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
if ((HAL_CRC_Append(&crc, (uint8_t *)plain_str, plain_len) != HAL_OK)) {
|
|
CMD_ERR("crc append failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
if (HAL_CRC_Finish(&crc, &res) != HAL_OK) {
|
|
CMD_ERR("crc deinit failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
printf("crc result:0x%x\n", res);
|
|
|
|
out_plain:
|
|
cmd_free(plain_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_encrypto_md5_exec(char *cmd)
|
|
{
|
|
char *plain_str = NULL;
|
|
int plain_len = 0;
|
|
CE_MD5_Handler md5;
|
|
uint32_t res[4];
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
int32_t cnt;
|
|
|
|
plain_str = (char *)cmd_malloc(CE_PLAIN_MAX_LEN);
|
|
if (plain_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "p=%s", plain_str);
|
|
/* check param */
|
|
if (cnt != 1) {
|
|
CMD_ERR("invalid param number %s\n", cmd);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
|
|
if (HAL_MD5_Init(&md5, CE_CTL_IVMODE_SHA_MD5_FIPS180, NULL) != HAL_OK) {
|
|
CMD_ERR("md5 init failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
|
|
plain_len = cmd_strlen(plain_str);
|
|
if (HAL_MD5_Append(&md5, (uint8_t *)plain_str, plain_len) != HAL_OK) {
|
|
CMD_ERR("md5 append failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
if (HAL_MD5_Finish(&md5, res) != HAL_OK) {
|
|
CMD_ERR("md5 deinit failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
printf("md5 result:");
|
|
cmd_print_uint8_array((uint8_t *)res, 16);
|
|
|
|
out_plain:
|
|
cmd_free(plain_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_encrypto_sha1_exec(char *cmd)
|
|
{
|
|
char *plain_str = NULL;
|
|
int plain_len = 0;
|
|
CE_SHA1_Handler sha1;
|
|
uint32_t res[5];
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
int32_t cnt;
|
|
|
|
plain_str = (char *)cmd_malloc(CE_PLAIN_MAX_LEN);
|
|
if (plain_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "p=%s", plain_str);
|
|
|
|
/* check param */
|
|
if (cnt != 1) {
|
|
CMD_ERR("invalid param number %s\n", cmd);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
|
|
if (HAL_SHA1_Init(&sha1, CE_CTL_IVMODE_SHA_MD5_FIPS180, NULL) != HAL_OK) {
|
|
CMD_ERR("sha1 init failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
|
|
plain_len = cmd_strlen(plain_str);
|
|
if (HAL_SHA1_Append(&sha1, (uint8_t *)plain_str, plain_len) != HAL_OK) {
|
|
CMD_ERR("sha1 append failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
if (HAL_SHA1_Finish(&sha1, res) != HAL_OK) {
|
|
CMD_ERR("sha1 deinit failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
printf("sha1 result:");
|
|
cmd_print_uint8_array((uint8_t *)res, 20);
|
|
|
|
out_plain:
|
|
cmd_free(plain_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_encrypto_sha256_exec(char *cmd)
|
|
{
|
|
char *plain_str = NULL;
|
|
int plain_len = 0;
|
|
CE_SHA1_Handler sha1;
|
|
uint32_t res[8];
|
|
enum cmd_status ret = CMD_STATUS_ACKED;
|
|
int32_t cnt;
|
|
|
|
plain_str = (char *)cmd_malloc(CE_PLAIN_MAX_LEN);
|
|
if (plain_str == NULL) {
|
|
CMD_ERR("malloc failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "p=%s", plain_str);
|
|
/* check param */
|
|
if (cnt != 1) {
|
|
CMD_ERR("invalid param number %s\n", cmd);
|
|
ret = CMD_STATUS_INVALID_ARG;
|
|
goto out_plain;
|
|
}
|
|
|
|
if (HAL_SHA256_Init(&sha1, CE_CTL_IVMODE_SHA_MD5_FIPS180, NULL) != HAL_OK) {
|
|
CMD_ERR("sha1 init failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
|
|
plain_len = cmd_strlen(plain_str);
|
|
if (HAL_SHA256_Append(&sha1, (uint8_t *)plain_str, plain_len) != HAL_OK) {
|
|
CMD_ERR("sha256 append failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
if (HAL_SHA256_Finish(&sha1, res) != HAL_OK) {
|
|
CMD_ERR("sha1 deinit failed\n");
|
|
ret = CMD_STATUS_FAIL;
|
|
goto out_plain;
|
|
}
|
|
printf("sha256 result:");
|
|
cmd_print_uint8_array((uint8_t *)res, 32);
|
|
|
|
out_plain:
|
|
cmd_free(plain_str);
|
|
return ret;
|
|
}
|
|
|
|
static enum cmd_status cmd_random_prng_exec(char *cmd)
|
|
{
|
|
uint8_t random[5];
|
|
|
|
if (HAL_PRNG_Generate(random, 5) != HAL_OK) {
|
|
CMD_ERR("prng generate failed\n");
|
|
return CMD_STATUS_FAIL;
|
|
}
|
|
printf("prng result:");
|
|
cmd_print_uint8_array(random, 5);
|
|
|
|
return CMD_STATUS_ACKED;
|
|
}
|
|
|
|
#if (CONFIG_CHIP_ARCH_VER > 1)
|
|
static enum cmd_status cmd_random_trng_exec(char *cmd)
|
|
{
|
|
char type_str[3];
|
|
uint8_t type;
|
|
uint32_t ramdom[4];
|
|
int32_t cnt;
|
|
|
|
/* get param */
|
|
cnt = cmd_sscanf(cmd, "t=%3s", type_str);
|
|
/* check param */
|
|
if (cnt != 1) {
|
|
CMD_ERR("invalid param number %s\n", cmd);
|
|
return CMD_STATUS_INVALID_ARG;
|
|
}
|
|
|
|
if (cmd_strcmp(type_str, "crc") == 0) {
|
|
type = 0;
|
|
} else if (cmd_strcmp(type_str, "xor") == 0) {
|
|
type = 1;
|
|
} else {
|
|
return CMD_STATUS_FAIL;
|
|
}
|
|
|
|
if (HAL_TRNG_Extract(type, ramdom) != HAL_OK) {
|
|
CMD_ERR("trng extract failed\n");
|
|
return CMD_STATUS_FAIL;
|
|
}
|
|
|
|
cmd_write_respond(CMD_STATUS_OK, "OK");
|
|
|
|
printf("trng result: %u %u %u %u\n", ramdom[0], ramdom[1], ramdom[2], ramdom[3]);
|
|
|
|
return CMD_STATUS_ACKED;
|
|
}
|
|
#endif
|
|
static const struct cmd_data g_encrypto_cmds[] = {
|
|
{ "aes", cmd_encrypto_aes_exec },
|
|
{ "des", cmd_encrypto_des_exec },
|
|
{ "3des", cmd_encrypto_3des_exec },
|
|
{ "crc", cmd_encrypto_crc_exec },
|
|
{ "md5", cmd_encrypto_md5_exec },
|
|
{ "sha1", cmd_encrypto_sha1_exec },
|
|
{ "sha256", cmd_encrypto_sha256_exec },
|
|
};
|
|
|
|
enum cmd_status cmd_encrypto_exec(char *cmd)
|
|
{
|
|
return cmd_exec(cmd, g_encrypto_cmds, cmd_nitems(g_encrypto_cmds));
|
|
}
|
|
|
|
static const struct cmd_data g_decrypto_cmds[] = {
|
|
{ "aes", cmd_decrypto_aes_exec },
|
|
{ "des", cmd_decrypto_des_exec },
|
|
{ "3des", cmd_decrypto_3des_exec },
|
|
};
|
|
|
|
enum cmd_status cmd_decrypto_exec(char *cmd)
|
|
{
|
|
return cmd_exec(cmd, g_decrypto_cmds, cmd_nitems(g_decrypto_cmds));
|
|
}
|
|
|
|
static const struct cmd_data g_random_cmds[] = {
|
|
{ "prng", cmd_random_prng_exec },
|
|
#if (CONFIG_CHIP_ARCH_VER > 1)
|
|
{ "trng", cmd_random_trng_exec },
|
|
#endif
|
|
};
|
|
|
|
enum cmd_status cmd_random_exec(char *cmd)
|
|
{
|
|
return cmd_exec(cmd, g_random_cmds, cmd_nitems(g_random_cmds));
|
|
}
|
|
|
|
static const struct cmd_data g_crypto_cmds[] = {
|
|
{ "encrypto", cmd_encrypto_exec },
|
|
{ "decrypto", cmd_decrypto_exec },
|
|
{ "random", cmd_random_exec },
|
|
};
|
|
|
|
enum cmd_status cmd_crypto_exec(char *cmd)
|
|
{
|
|
return cmd_exec(cmd, g_crypto_cmds, cmd_nitems(g_crypto_cmds));
|
|
}
|
|
|