Files
kunlun/plc/halmac/test/mac_cert_sec_lib.c
2024-09-28 14:24:04 +08:00

1220 lines
38 KiB
C

/****************************************************************************
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.
****************************************************************************/
#include "os_utils.h"
#include "iot_config.h"
#include "iot_io_api.h"
#include "iot_errno_api.h"
#include "iot_crypto.h"
#include "iot_utils_api.h"
#include "iot_pkt.h"
#include "plc_cert_test.h"
#include "mac_cert_sec_lib.h"
#include "iot_crypto_hash_api.h"
#include "iot_crypto_dsa_api.h"
#include "iot_oem.h"
#if SUPPORT_SMART_GRID
#define CERT_TEST_HDR_LEN (sizeof(cert_test_t))
#else /* SUPPORT_SMART_GRID */
#define CERT_TEST_HDR_LEN (sizeof(spg_cert_test_hdr_t) + \
sizeof(spg_cert_test_cmd_t) + sizeof(spg_cert_test_dm_t))
#endif /* SUPPORT_SMART_GRID */
/* mac cert security war context */
typedef struct _mac_cert_sec_war {
/* current security cmd */
uint8_t cur_cmd;
/* indicate current security is done or not */
uint8_t is_sec_done;
/* indicate current security is need war or not */
uint8_t is_need_war;
/* war source data pkt */
iot_pkt_t *src_pkt;
/* war backup result pkt */
iot_pkt_t *rst_pkt;
} mac_cert_sec_war_t;
#if MAC_CERT_SEC_SUPPORT
const uint8_t g_cert_aes_cbc_iv[16] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
0x99, 0x00, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF,
};
const uint8_t g_cert_aes_gcm_iv[12] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
0x99, 0x00, 0xAA, 0xBB,
};
const uint8_t g_cert_ecdsa_pub1[64] = {
0x7c, 0xfe, 0x00, 0xb3, 0x79, 0x7e, 0x70, 0x7b,
0x0e, 0x73, 0x8e, 0xb0, 0xa1, 0x44, 0x38, 0x65,
0xb9, 0x90, 0x04, 0x99, 0x9b, 0xb4, 0x41, 0xa1,
0x6d, 0x07, 0xca, 0x4b, 0xb0, 0xc5, 0x20, 0xb5,
0x00, 0xcd, 0xdc, 0x88, 0x5d, 0x8c, 0x9b, 0x52,
0x41, 0xe8, 0x87, 0x03, 0x70, 0xd5, 0xc5, 0xdd,
0x6b, 0x57, 0x66, 0xe7, 0xd7, 0xe3, 0x8f, 0xf3,
0x82, 0x0e, 0xbb, 0xcb, 0x49, 0x50, 0x9a, 0x12,
};
const uint8_t g_cert_ecdsa_pri1[32] = {
0x79, 0x9b, 0x41, 0x80, 0x71, 0x84, 0x9c, 0xd2,
0x4e, 0x20, 0x12, 0xc6, 0x37, 0x25, 0x07, 0x30,
0x3f, 0xaa, 0xb1, 0x3d, 0xbd, 0xa0, 0xe1, 0x3f,
0xda, 0x09, 0x48, 0xad, 0xfa, 0x62, 0x5d, 0xf3
};
const uint8_t g_cert_ecdsa_pub2[64] = {
0x5d, 0x22, 0x0d, 0xdd, 0x4b, 0x7d, 0x90, 0x3a,
0x12, 0xe7, 0xfa, 0xdb, 0xa4, 0x6b, 0x12, 0xf1,
0x23, 0x13, 0x2f, 0x05, 0x2e, 0x37, 0x3d, 0x79,
0x43, 0x91, 0x9c, 0x19, 0x25, 0xff, 0x37, 0xdf,
0x44, 0xcc, 0x97, 0xec, 0xd3, 0x7f, 0xf6, 0x6c,
0xdd, 0x67, 0x49, 0x98, 0xfe, 0x16, 0xb5, 0xa1,
0xf5, 0x7d, 0xc9, 0xf9, 0xb2, 0x0e, 0x62, 0x9b,
0x80, 0x43, 0x10, 0x23, 0x67, 0x84, 0x04, 0x18
};
const uint8_t g_cert_ecdsa_pri2[32] = {
0x28, 0xfe, 0x58, 0x6c, 0xc9, 0xea, 0x95, 0x94,
0x49, 0x97, 0x58, 0xef, 0x4c, 0x9f, 0xec, 0x49,
0x84, 0x50, 0x7c, 0xc6, 0x36, 0xf0, 0x9e, 0x2a,
0xcb, 0x99, 0xaa, 0xb8, 0x78, 0x5b, 0xef, 0x72
};
const uint8_t g_cert_ecdsa_pub3[64] = {
0x80, 0xb7, 0xeb, 0x44, 0x52, 0x39, 0x6c, 0x02,
0xee, 0xcb, 0x8a, 0x76, 0x5d, 0x62, 0x38, 0xed,
0x2c, 0xa4, 0x83, 0xd5, 0x54, 0x73, 0x3c, 0x7e,
0x80, 0x0b, 0x99, 0x62, 0x4b, 0x71, 0x46, 0xe1,
0x12, 0x9f, 0xb4, 0x31, 0x10, 0xfa, 0x5e, 0x12,
0x49, 0x89, 0xb0, 0x01, 0x54, 0x38, 0x79, 0x49,
0x75, 0xb5, 0xb4, 0x91, 0x2c, 0xb6, 0x80, 0x1b,
0x73, 0xe2, 0x1c, 0xa4, 0x2f, 0x5a, 0x34, 0x9b
};
const uint8_t g_cert_ecdsa_pri3[32] = {
0x41, 0x71, 0xe0, 0x5f, 0x2d, 0x26, 0x34, 0xe2,
0x67, 0xa8, 0x7b, 0x8e, 0xd0, 0xef, 0x79, 0xb4,
0xcd, 0xa2, 0x28, 0xb3, 0x07, 0xa6, 0xe6, 0x1f,
0xd5, 0x74, 0x30, 0x4d, 0x1a, 0x28, 0xb4, 0xb3
};
const uint8_t g_cert_sm2_pri1[32] = {
0x45, 0xb0, 0x35, 0xa0, 0x75, 0x1a, 0xc4, 0x8d,
0x86, 0x25, 0x1c, 0xd8, 0x64, 0x4b, 0x38, 0x2c,
0xce, 0x06, 0xc3, 0xfb, 0xa0, 0x25, 0x6a, 0x48,
0x0b, 0x90, 0x17, 0x14, 0x2f, 0x4c, 0xa4, 0x2a
};
const uint8_t g_cert_sm2_pub1[64] = {
0xc3, 0xf2, 0x26, 0x7e, 0xfa, 0x97, 0x99, 0xc3,
0x95, 0xfe, 0x02, 0x00, 0xff, 0xc7, 0xcc, 0x9c,
0xbf, 0x78, 0x04, 0x1e, 0xa5, 0xa2, 0x29, 0xf3,
0x2e, 0xa4, 0x02, 0xf4, 0x49, 0xd0, 0x4e, 0x0f,
0xf5, 0x43, 0x32, 0x68, 0xd8, 0xca, 0x54, 0xb8,
0xe1, 0xfb, 0x53, 0x4b, 0x40, 0x05, 0xb5, 0x2b,
0xa8, 0x95, 0xb6, 0x66, 0xee, 0xf7, 0x5a, 0xc0,
0x45, 0xec, 0x9c, 0xa8, 0x00, 0x86, 0xed, 0xce
};
const uint8_t g_cert_sm2_pri2[32] = {
0x9e, 0xac, 0x97, 0x6d, 0xa1, 0x07, 0x56, 0x93,
0x3e, 0x85, 0xc8, 0xe7, 0xbd, 0xd6, 0x4d, 0x07,
0x2e, 0x0c, 0x4c, 0xb7, 0x75, 0x21, 0x8b, 0xd5,
0xb2, 0x36, 0xbf, 0x3c, 0xb6, 0x80, 0x42, 0x59
};
const uint8_t g_cert_sm2_pub2[64] = {
0x34, 0x7e, 0x0a, 0x12, 0x46, 0x9c, 0x54, 0x9d,
0xc9, 0x64, 0xb0, 0x88, 0x55, 0x43, 0x1e, 0x3a,
0x36, 0x0b, 0x0b, 0x5b, 0x99, 0xa5, 0xc6, 0xaa,
0x47, 0x07, 0xa9, 0x8f, 0xd2, 0x05, 0x6b, 0x37,
0x96, 0x67, 0x6d, 0x5e, 0xac, 0x25, 0x08, 0x7a,
0xd8, 0x45, 0x45, 0x92, 0x2f, 0x37, 0x36, 0x51,
0x36, 0xb9, 0xee, 0xc8, 0x75, 0x81, 0x8b, 0xde,
0x83, 0xb9, 0xf6, 0xeb, 0x40, 0x7e, 0xf7, 0x75
};
const uint8_t g_cert_sm2_pri3[32] = {
0xe1, 0x10, 0x38, 0x91, 0x90, 0x99, 0x19, 0xcc,
0x2f, 0xdc, 0xff, 0xe7, 0x1f, 0xe3, 0xf5, 0xce,
0xb0, 0x1e, 0xc1, 0xff, 0x75, 0x99, 0x48, 0x5c,
0x9a, 0x00, 0xc3, 0x6e, 0x97, 0xc4, 0xbb, 0xf9
};
const uint8_t g_cert_sm2_pub3[64] = {
0x03, 0x3c, 0x99, 0x12, 0x4a, 0x3d, 0xfe, 0xb0,
0xab, 0x81, 0x56, 0x24, 0x98, 0xf4, 0x44, 0xef,
0xfc, 0x2a, 0x37, 0x65, 0x23, 0x1b, 0xa4, 0x78,
0xa0, 0x7d, 0x77, 0x2a, 0x50, 0x13, 0xde, 0xce,
0x33, 0x28, 0xb8, 0xf1, 0x8c, 0x74, 0xd8, 0x34,
0xe4, 0x38, 0xc2, 0x22, 0xcc, 0xe3, 0x94, 0x2a,
0xce, 0xf5, 0x55, 0xd7, 0xa8, 0x15, 0x15, 0xcd,
0xd4, 0x42, 0x20, 0xd4, 0x3e, 0x6c, 0x24, 0xab
};
#if MAC_CERT_SEC_ENCRYPT_WAR
static mac_cert_sec_war_t g_cert_sec_war_info = {0};
#endif
#if CERT_TEST_DEBUG
static void mac_cert_test_sec_data_dump(const char* str, uint8_t* buf,
uint32_t len)
{
static char log_buf[1024];
uint32_t offset = 0;
offset = iot_sprintf(log_buf, "%s[%d]:", str, len);
for (uint32_t i = 0; i < len; ++i) {
offset += iot_sprintf(log_buf + offset, "%02X", buf[i]);
if (IOT_ARRAY_CNT(log_buf) <= offset + 4) {
break;
}
}
log_buf[offset] = 0;
iot_printf("%s\n", log_buf);
}
#else
static void mac_cert_test_sec_data_dump(const char* str, uint8_t* buf,
uint32_t len)
{
(void)str;
(void)buf;
(void)len;
}
#endif
static iot_pkt_t *mac_cert_sec_sha256(uint8_t *input, uint32_t len)
{
uint8_t *data;
cert_test_sec_random_t *src;
cert_test_sec_hash_t *result;
iot_pkt_t *ret_pkt;
src = (cert_test_sec_random_t *)input;
mac_cert_test_sec_data_dump("sha256_test_input:", src->data, src->len);
if ((src->len + sizeof(*src)) > len) {
return NULL;
}
ret_pkt = iot_pkt_alloc(32 + sizeof(*result) + CERT_TEST_HDR_LEN,
PLC_MAC_COMMON_MID);
IOT_ASSERT(ret_pkt);
result = (cert_test_sec_hash_t *)((uint8_t *)iot_pkt_data(ret_pkt)
+ CERT_TEST_HDR_LEN);
data = (uint8_t *)result + sizeof(*result);
if (ERR_OK == iot_crypto_sha256(src->data, src->len, data)) {
result->len = 32;
iot_pkt_set_tail(ret_pkt, data + result->len);
mac_cert_test_sec_data_dump("sha256_hash:", result->data,
result->len);
return ret_pkt;
} else {
iot_pkt_free(ret_pkt);
IOT_ASSERT(0);
return NULL;
}
}
static iot_pkt_t *mac_cert_test_sec_sm3(uint8_t *input, uint32_t len)
{
uint8_t *data;
cert_test_sec_random_t *src;
cert_test_sec_hash_t *hash;
iot_pkt_t *ret_pkt;
src = (cert_test_sec_random_t *)input;
if ((src->len + sizeof(*src)) > len) {
return NULL;
}
mac_cert_test_sec_data_dump("sm3 tset input", src->data, src->len);
ret_pkt = iot_pkt_alloc(32 + sizeof(*hash) + CERT_TEST_HDR_LEN,
PLC_MAC_COMMON_MID);
IOT_ASSERT(ret_pkt);
hash = (cert_test_sec_hash_t *)((uint8_t *)iot_pkt_data(ret_pkt)
+ CERT_TEST_HDR_LEN);
data = (uint8_t *)hash + sizeof(*hash);
if (ERR_OK == iot_crypto_sm3(src->data, (uint32_t)src->len, data, 32)) {
hash->len = 32;
iot_pkt_set_tail(ret_pkt, data + hash->len);
mac_cert_test_sec_data_dump("sm3_hash:", hash->data, hash->len);
return ret_pkt;
} else {
iot_pkt_free(ret_pkt);
IOT_ASSERT(0);
return NULL;
}
}
static iot_pkt_t *mac_cert_sec_aes_cbc_encrypt(uint8_t *input,
uint32_t len)
{
uint32_t offset, shift;
cert_test_sec_key_t *key_src;
cert_test_sec_random_t *random_src;
cert_test_sec_iv_t *iv;
cert_test_sec_ciphertext_t *encrypt;
iot_pkt_t *ret_pkt = NULL;
key_src = (cert_test_sec_key_t *)input;
if (16 != key_src->len) {
iot_printf("aes_cbc_enc key %d invalid\n", key_src->len);
return ret_pkt;
}
random_src = (cert_test_sec_random_t *)(input + sizeof(*key_src)
+ key_src->len);
if ((sizeof(*key_src) + key_src->len + sizeof(*random_src)
+ random_src->len) > len) {
iot_printf("aes_cbc_enc key:%d, rand:%d, total:%d\n",
key_src->len, random_src->len, len);
return ret_pkt;
}
#if CERT_TEST_DEBUG
iot_printf("aes_cbc_enc. key:%u\n", key_src->len);
mem_dump_byte(key_src->data, key_src->len);
iot_printf("aes_cbc_enc. random:%u\n", random_src->len);
mem_dump_byte(random_src->data, random_src->len);
#endif
/* 1. IV length: 16byte,
* 2. encrypt result length same as input random length
*/
shift = CERT_TEST_HDR_LEN + 16 + sizeof(*iv) + sizeof(*encrypt);
/* set output encrypt data address 4byte alignment */
if (shift & 0x03) {
offset = 4 - (shift & 0x03);
} else {
offset = 0;
}
ret_pkt = iot_pkt_alloc(random_src->len + shift + offset,
PLC_MAC_COMMON_MID);
IOT_ASSERT(ret_pkt);
#if MAC_CERT_SEC_ENCRYPT_WAR
if (g_cert_sec_war_info.is_sec_done) {
iot_pkt_cpy(ret_pkt, g_cert_sec_war_info.rst_pkt);
/* send reply ot test bed too fast may lead to test failure */
os_delay(1000);
mac_cert_test_sec_data_dump("aes_cbc_enc. not enc",
iot_pkt_data(ret_pkt), iot_pkt_data_len(ret_pkt));
return ret_pkt;
}
#endif
iv = (cert_test_sec_iv_t *)(iot_pkt_data(ret_pkt) + offset
+ CERT_TEST_HDR_LEN);
iv->len = 16;
encrypt = (cert_test_sec_ciphertext_t *)((uint8_t *)iv + sizeof(*iv)
+ iv->len);
encrypt->len = random_src->len;
iot_pkt_set_tail(ret_pkt, encrypt->data + encrypt->len);
iot_pkt_pull(ret_pkt, offset);
#if CERT_TEST_DEBUG
iot_printf("encrypt data addr = 0x%08x, shift:%d, offset=%d\n",
(uint32_t)encrypt->data, shift, offset);
IOT_ASSERT(0 == ((uint32_t)encrypt->data & 0x03));
#endif
if (ERR_OK != iot_crypto_aes_cbc_with_key(key_src->data, key_src->len << 3,
IOT_AES_ENCRYPT, random_src->len, (uint8_t *)g_cert_aes_cbc_iv,
random_src->data, encrypt->data, NULL, 100000)) {
iot_pkt_free(ret_pkt);
ret_pkt = NULL;
} else {
os_mem_cpy(iv->data, g_cert_aes_cbc_iv, sizeof(g_cert_aes_cbc_iv));
}
return ret_pkt;
}
static iot_pkt_t *mac_cert_sec_aes_cbc_decrypt(uint8_t *input,
uint32_t len)
{
uint32_t offset, shift;
cert_test_sec_key_t *key_src;
cert_test_sec_iv_t *iv_src;
cert_test_sec_ciphertext_t *ciphertext_src;
cert_test_sec_plaintext_t *plaintext_rst;
iot_pkt_t *ret_pkt = NULL;
/* input: key + iv + ciphertext */
key_src = (cert_test_sec_key_t *)input;
if (16 != key_src->len) {
iot_printf("aes_cbc_dec key %d invalid\n", key_src->len);
return ret_pkt;
}
iv_src = (cert_test_sec_iv_t *)((uint8_t *)key_src->data + key_src->len);
if (16 != iv_src->len) {
iot_printf("aes_cbc_dec iv %d invalid\n", iv_src->len);
return ret_pkt;
}
ciphertext_src = (cert_test_sec_ciphertext_t *)((uint8_t *)iv_src->data
+ iv_src->len);
if ((sizeof(*key_src) + key_src->len + sizeof(*iv_src) + iv_src->len
+ sizeof(*ciphertext_src) + ciphertext_src->len) > len) {
iot_printf("aes_cbc_dec key:%u, iv:%u, cipher:%u, total:%u\n",
key_src->len, iv_src->len, ciphertext_src->len, len);
return ret_pkt;
}
mac_cert_test_sec_data_dump("aes_cbc_dec. key",
key_src->data, key_src->len);
mac_cert_test_sec_data_dump("aes_cbc_dec. iv",
iv_src->data, iv_src->len);
mac_cert_test_sec_data_dump("aes_cbc_dec. ciphertext",
ciphertext_src->data, ciphertext_src->len);
/* output: plaintext only, length same as input ciphertext length */
shift = CERT_TEST_HDR_LEN + sizeof(*plaintext_rst);
/* set output data address 4byte alignment */
if (shift & 0x03) {
offset = 4 - (shift & 0x03);
} else {
offset = 0;
}
ret_pkt = iot_pkt_alloc(ciphertext_src->len + shift + offset,
PLC_MAC_COMMON_MID);
IOT_ASSERT(ret_pkt);
plaintext_rst = (cert_test_sec_plaintext_t *)(iot_pkt_data(ret_pkt)
+ offset + CERT_TEST_HDR_LEN);
plaintext_rst->len = ciphertext_src->len;
iot_pkt_set_tail(ret_pkt, plaintext_rst->data + plaintext_rst->len);
iot_pkt_pull(ret_pkt, offset);
#if CERT_TEST_DEBUG
iot_printf("aes_cbc_dec data addr = 0x%08x, shift:%d, offset=%d\n",
(uint32_t)plaintext_rst->data, shift, offset);
IOT_ASSERT(0 == ((uint32_t)plaintext_rst->data & 0x03));
#endif
if (ERR_OK != iot_crypto_aes_cbc_with_key(key_src->data, key_src->len << 3,
IOT_AES_DECRYPT, ciphertext_src->len, iv_src->data,
ciphertext_src->data, plaintext_rst->data, NULL, 1)) {
iot_pkt_free(ret_pkt);
ret_pkt = NULL;
}
return ret_pkt;
}
static iot_pkt_t *mac_cert_sec_aes_gcm_encrypt(uint8_t *input,
uint32_t len)
{
uint32_t offset, shift;
cert_test_sec_key_t *key_src;
cert_test_sec_random_t *random_src;
cert_test_sec_mactag_t *mactag;
cert_test_sec_iv_t *iv;
cert_test_sec_ciphertext_t *encrypt;
iot_pkt_t *ret_pkt = NULL;
uint8_t tmp_iv[12];
uint8_t *data;
iot_pkt_t *tmp_pkt = NULL;
key_src = (cert_test_sec_key_t *)input;
if (16 != key_src->len) {
iot_printf("aes_gcm_enc key %d invalid\n", key_src->len);
return ret_pkt;
}
random_src = (cert_test_sec_random_t *)(input + sizeof(*key_src)
+ key_src->len);
if ((sizeof(*key_src) + key_src->len + sizeof(*random_src)
+ random_src->len) > len) {
iot_printf("aes_gcm_enc key:%d, rand:%d, total:%d\n",
key_src->len, random_src->len, len);
return ret_pkt;
}
mac_cert_test_sec_data_dump("aes_gcm_enc. key", key_src->data,
key_src->len);
mac_cert_test_sec_data_dump("aes_gcm_enc. random", random_src->data,
random_src->len);
/* 1. mac_tag length: 16byte
* 2. IV length: 12byte,
* 3. encrypt result length same as input random length
*/
shift = CERT_TEST_HDR_LEN + 16 + sizeof(*mactag)
+ sizeof(g_cert_aes_gcm_iv) + sizeof(*iv)
+ sizeof(*encrypt);
/* set output encrypt data address 4byte alignment */
if (shift & 0x03) {
offset = 4 - (shift & 0x03);
} else {
offset = 0;
}
ret_pkt = iot_pkt_alloc(random_src->len + shift + offset,
PLC_MAC_COMMON_MID);
IOT_ASSERT(ret_pkt);
#if MAC_CERT_SEC_ENCRYPT_WAR
if (g_cert_sec_war_info.is_sec_done) {
iot_pkt_cpy(ret_pkt, g_cert_sec_war_info.rst_pkt);
/* send reply ot test bed too fast may lead to test failure */
os_delay(1000);
mac_cert_test_sec_data_dump("aes_gcm_enc. not enc",
iot_pkt_data(ret_pkt), iot_pkt_data_len(ret_pkt));
return ret_pkt;
}
#endif
mactag = (cert_test_sec_mactag_t *)(iot_pkt_data(ret_pkt) + offset
+ CERT_TEST_HDR_LEN);
mactag->len = 16;
iv = (cert_test_sec_iv_t *)((uint8_t *)mactag + sizeof(*mactag)
+ mactag->len);
iv->len = sizeof(g_cert_aes_gcm_iv);
encrypt = (cert_test_sec_ciphertext_t *)((uint8_t *)iv + sizeof(*iv)
+ iv->len);
encrypt->len = random_src->len;
iot_pkt_set_tail(ret_pkt, encrypt->data + encrypt->len);
iot_pkt_pull(ret_pkt, offset);
#if CERT_TEST_DEBUG
iot_printf("encrypt data addr = 0x%08x, shift:%d, offset=%d\n",
(uint32_t)encrypt->data, shift, offset);
IOT_ASSERT(0 == ((uint32_t)encrypt->data & 0x03));
#endif
os_mem_cpy(tmp_iv, g_cert_aes_gcm_iv, sizeof(g_cert_aes_gcm_iv));
/* input data 4byte alignment */
if ((uint32_t)random_src->data & 0x03) {
tmp_pkt = iot_pkt_alloc(random_src->len, PLC_MAC_COMMON_MID);
IOT_ASSERT(tmp_pkt);
data = iot_pkt_data(tmp_pkt);
os_mem_cpy(data, random_src->data, random_src->len);
} else {
data = random_src->data;
}
if (ERR_OK != iot_crypto_aes_gcm_cert(1, key_src->data, key_src->len * 8,
data, random_src->len, tmp_iv, sizeof(g_cert_aes_gcm_iv),
NULL, 0, encrypt->data, mactag->data, 100000)) {
iot_pkt_free(ret_pkt);
ret_pkt = NULL;
} else {
//TODO: base on cert fix (tmp_iv or g_cert_aes_gcm_iv)
os_mem_cpy(iv->data, g_cert_aes_gcm_iv, sizeof(g_cert_aes_gcm_iv));
}
if (tmp_pkt) {
iot_pkt_free(tmp_pkt);
}
return ret_pkt;
}
static iot_pkt_t *mac_cert_sec_aes_gcm_decrypt(uint8_t *input, uint32_t len)
{
cert_test_sec_key_t *key_src;
cert_test_sec_iv_t *iv_src;
cert_test_sec_ciphertext_t *ciphertext_src;
cert_test_sec_plaintext_t *plaintext_rst;
iot_pkt_t *ret_pkt = NULL;
/* input: key + iv + ciphertext */
key_src = (cert_test_sec_key_t *)input;
if (16 != key_src->len) {
iot_printf("aes_gcm_dec key %d invalid\n", key_src->len);
return ret_pkt;
}
iv_src = (cert_test_sec_iv_t *)((uint8_t *)key_src->data + key_src->len);
if (16 < iv_src->len) {
iot_printf("aes_gcm_dec iv %d invalid\n", iv_src->len);
return ret_pkt;
}
ciphertext_src = (cert_test_sec_ciphertext_t *)((uint8_t *)iv_src->data
+ iv_src->len);
if ((sizeof(*key_src) + key_src->len + sizeof(*iv_src) + iv_src->len
+ sizeof(*ciphertext_src) + ciphertext_src->len) > len) {
iot_printf("aes_gcm_dec key:%u, iv:%u, cipher:%u, total:%u\n",
key_src->len, iv_src->len, ciphertext_src->len, len);
return ret_pkt;
}
mac_cert_test_sec_data_dump("aes_gcm_dec. key",
key_src->data, key_src->len);
mac_cert_test_sec_data_dump("aes_gcm_dec. iv",
iv_src->data, iv_src->len);
mac_cert_test_sec_data_dump("aes_gcm_dec. ciphertext",
ciphertext_src->data, ciphertext_src->len);
/* output: plaintext only, length same as input ciphertext length */
ret_pkt = iot_pkt_alloc(CERT_TEST_HDR_LEN + sizeof(*plaintext_rst)
+ ciphertext_src->len, PLC_MAC_COMMON_MID);
IOT_ASSERT(ret_pkt);
plaintext_rst = (cert_test_sec_plaintext_t *)(iot_pkt_data(ret_pkt)
+ CERT_TEST_HDR_LEN);
plaintext_rst->len = ciphertext_src->len;
iot_pkt_set_tail(ret_pkt, plaintext_rst->data + plaintext_rst->len);
if (ERR_OK != iot_crypto_aes_gcm_cert(0, key_src->data, key_src->len * 8,
ciphertext_src->data, ciphertext_src->len, iv_src->data, iv_src->len,
NULL, 0, plaintext_rst->data, NULL, 1)) {
iot_pkt_free(ret_pkt);
ret_pkt = NULL;
}
return ret_pkt;
}
static iot_pkt_t *mac_cert_sec_sm4_cbc_encrypt(uint8_t *input, uint32_t len)
{
uint32_t offset, shift;
cert_test_sec_key_t *key_src;
cert_test_sec_random_t *random_src;
cert_test_sec_iv_t *iv;
cert_test_sec_ciphertext_t *encrypt;
iot_pkt_t *ret_pkt = NULL;
iot_pkt_t *tmp_pkt = NULL;
uint8_t *input_data;
key_src = (cert_test_sec_key_t *)input;
if (16 != key_src->len) {
iot_printf("sm4_cbc_enc key %d invalid\n", key_src->len);
return ret_pkt;
}
random_src = (cert_test_sec_random_t *)(input + sizeof(*key_src)
+ key_src->len);
if ((sizeof(*key_src) + key_src->len + sizeof(*random_src)
+ random_src->len) > len) {
iot_printf("sm4_cbc_enc key:%d, rand:%d, total:%d\n",
key_src->len, random_src->len, len);
return ret_pkt;
}
#if CERT_TEST_DEBUG
iot_printf("sm4_cbc_enc. key:%u\n", key_src->len);
mem_dump_byte(key_src->data, key_src->len);
iot_printf("sm4_cbc_enc. random:%u\n", random_src->len);
mem_dump_byte(random_src->data, random_src->len);
#endif
/* 1. IV length: 16byte,
* 2. encrypt result length same as input random length
*/
shift = CERT_TEST_HDR_LEN + 16 + sizeof(*iv) + sizeof(*encrypt);
/* set output encrypt data address 4byte alignment */
if (shift & 0x03) {
offset = 4 - (shift & 0x03);
} else {
offset = 0;
}
ret_pkt = iot_pkt_alloc(random_src->len + shift + offset,
PLC_MAC_COMMON_MID);
IOT_ASSERT(ret_pkt);
#if MAC_CERT_SEC_ENCRYPT_WAR
if (g_cert_sec_war_info.is_sec_done) {
iot_pkt_cpy(ret_pkt, g_cert_sec_war_info.rst_pkt);
/* send reply ot test bed too fast may lead to test failure */
os_delay(1000);
mac_cert_test_sec_data_dump("sm4_cbc_enc. not enc",
iot_pkt_data(ret_pkt), iot_pkt_data_len(ret_pkt));
return ret_pkt;
}
#endif
iv = (cert_test_sec_iv_t *)(iot_pkt_data(ret_pkt) + offset
+ CERT_TEST_HDR_LEN);
iv->len = 16;
encrypt = (cert_test_sec_ciphertext_t *)((uint8_t *)iv + sizeof(*iv)
+ iv->len);
encrypt->len = random_src->len;
iot_pkt_set_tail(ret_pkt, encrypt->data + encrypt->len);
iot_pkt_pull(ret_pkt, offset);
#if CERT_TEST_DEBUG
iot_printf("encrypt data addr = 0x%08x, shift:%d, offset=%d\n",
(uint32_t)encrypt->data, shift, offset);
IOT_ASSERT(0 == ((uint32_t)encrypt->data & 0x03));
#endif
if ((uint32_t)random_src->data & 0x03) {
tmp_pkt = iot_pkt_alloc(random_src->len, PLC_MAC_COMMON_MID);
IOT_ASSERT(tmp_pkt);
input_data = iot_pkt_data(tmp_pkt);
os_mem_cpy(input_data, random_src->data, random_src->len);
} else {
input_data = random_src->data;
}
offset = encrypt->len; /* reuse save output length */
/* input IV same as aes cbc iv */
if (ERR_OK != iot_crypto_sm4(SM4_OPT_ENC, SM4_CBC, input_data,
random_src->len, encrypt->data, &offset,
key_src->data, (uint8_t *)g_cert_aes_cbc_iv, 100000)) {
iot_pkt_free(ret_pkt);
ret_pkt = NULL;
} else {
os_mem_cpy(iv->data, g_cert_aes_cbc_iv, sizeof(g_cert_aes_cbc_iv));
}
if (tmp_pkt) {
iot_pkt_free(tmp_pkt);
}
return ret_pkt;
}
static iot_pkt_t *mac_cert_sec_sm4_cbc_decrypt(uint8_t *input, uint32_t len)
{
uint32_t offset, shift;
cert_test_sec_key_t *key_src;
cert_test_sec_iv_t *iv_src;
cert_test_sec_ciphertext_t *ciphertext_src;
cert_test_sec_plaintext_t *plaintext_rst;
iot_pkt_t *ret_pkt = NULL;
iot_pkt_t *tmp_pkt = NULL;
uint8_t *input_data;
key_src = (cert_test_sec_key_t *)input;
if (16 != key_src->len) {
iot_printf("sm4_cbc_dec key %d invalid\n", key_src->len);
return ret_pkt;
}
iv_src = (cert_test_sec_iv_t *)((uint8_t *)key_src->data + key_src->len);
if (16 != iv_src->len) {
iot_printf("sm4_cbc_dec iv %d invalid\n", iv_src->len);
return ret_pkt;
}
ciphertext_src = (cert_test_sec_ciphertext_t *)((uint8_t *)iv_src->data
+ iv_src->len);
if ((sizeof(*key_src) + key_src->len + sizeof(*iv_src) + iv_src->len
+ sizeof(*ciphertext_src) + ciphertext_src->len) > len) {
iot_printf("sm4_cbc_dec key:%d, iv:%d, data:%d, total:%d\n",
key_src->len, iv_src->len, ciphertext_src->len, len);
return ret_pkt;
}
mac_cert_test_sec_data_dump("sm4_cbc_dec, key",
key_src->data, key_src->len);
mac_cert_test_sec_data_dump("sm4_cbc_dec, iv",
iv_src->data, iv_src->len);
mac_cert_test_sec_data_dump("sm4_cbc_dec, ciphertext",
ciphertext_src->data, ciphertext_src->len);
/* output: plaintext only, length same as input ciphertext length */
shift = CERT_TEST_HDR_LEN + sizeof(*plaintext_rst);
/* set output encrypt data address 4byte alignment */
if (shift & 0x03) {
offset = 4 - (shift & 0x03);
} else {
offset = 0;
}
ret_pkt = iot_pkt_alloc(ciphertext_src->len + shift + offset,
PLC_MAC_COMMON_MID);
IOT_ASSERT(ret_pkt);
plaintext_rst = (cert_test_sec_plaintext_t *)(iot_pkt_data(ret_pkt)
+ CERT_TEST_HDR_LEN + offset);
plaintext_rst->len = ciphertext_src->len;
iot_pkt_set_tail(ret_pkt, plaintext_rst->data + plaintext_rst->len);
iot_pkt_pull(ret_pkt, offset);
if ((uint32_t)ciphertext_src->data & 0x03) {
tmp_pkt = iot_pkt_alloc(ciphertext_src->len, PLC_MAC_COMMON_MID);
IOT_ASSERT(tmp_pkt);
input_data = iot_pkt_data(tmp_pkt);
os_mem_cpy(input_data, ciphertext_src->data, ciphertext_src->len);
} else {
input_data = ciphertext_src->data;
}
offset = plaintext_rst->len;
/* input IV same as aes cbc iv */
if (ERR_OK != iot_crypto_sm4(SM4_OPT_DEC, SM4_CBC, input_data,
ciphertext_src->len, plaintext_rst->data, &offset,
key_src->data, iv_src->data, 1)) {
iot_pkt_free(ret_pkt);
ret_pkt = NULL;
}
return ret_pkt;
}
static iot_pkt_t *mac_cert_test_sec_dsa_sign(uint8_t is_sm2,
uint8_t *input, uint32_t len)
{
uint32_t ret;
uint8_t *data, reason = 0;
cert_test_sec_random_t *rand;
cert_test_sec_signature_r_t *rsp_r;
cert_test_sec_signature_s_t *rsp_s;
cert_test_sec_public_key_x_t *rsp_pub_x, *rsp_pub_y;
iot_pkt_t *rsp_pkt = NULL;
uint8_t r[32], s[32];
uint32_t public_key_len, r_len = 0, s_len = 0;
uint8_t *public_key = NULL;
rand = (cert_test_sec_random_t *)input;
if ((rand->len + sizeof(*rand)) > len
|| !rand->len) {
reason = 1;
goto out;
}
mac_cert_test_sec_data_dump("sign_input:", rand->data, rand->len);
if (!is_sm2) {
public_key = (uint8_t *)g_cert_ecdsa_pub1;
public_key_len = sizeof(g_cert_ecdsa_pub1);
ret = iot_crypto_ecdsa_with_sha256_sign(ecdsa_ecp_bp256r1, rand->data,
rand->len, g_cert_ecdsa_pri1, sizeof(g_cert_ecdsa_pri1),
r, &r_len, s, &s_len);
} else {
public_key = (uint8_t *)g_cert_sm2_pub1;
public_key_len = sizeof(g_cert_sm2_pub1);
ret = iot_crypto_sm2_sign(rand->data, rand->len,
(uint8_t *)g_iot_sec_sm2_user_id, IOT_SEC_SM2_USER_ID_LEN,
public_key, public_key_len,
r, &r_len, s, &s_len,
(uint8_t *)g_cert_sm2_pri1, sizeof(g_cert_sm2_pri1));
}
if (ret) {
reason = 2;
goto out;
}
mac_cert_test_sec_data_dump("sign_r:", r, r_len);
mac_cert_test_sec_data_dump("sign_s:", s, s_len);
len = sizeof(*rsp_r) + sizeof(*rsp_s) + sizeof(*rsp_pub_x) +
sizeof(*rsp_pub_x) + r_len + s_len + public_key_len +
CERT_TEST_HDR_LEN;
rsp_pkt = iot_pkt_alloc(len, PLC_MAC_COMMON_MID);
if (!rsp_pkt) {
reason = 3;
goto out;
}
/* uplink message layout is as follows:
* public key(x)
* public key(y)
* signature(r)
* signature(s)
*/
data = (uint8_t *)iot_pkt_data(rsp_pkt);
data += CERT_TEST_HDR_LEN;
rsp_pub_x = (cert_test_sec_public_key_x_t *)data;
rsp_pub_x->len = (uint8_t)(public_key_len >> 1);
os_mem_cpy(rsp_pub_x->data, public_key, rsp_pub_x->len);
data += rsp_pub_x->len + sizeof(*rsp_pub_x);
rsp_pub_y = (cert_test_sec_public_key_x_t *)data;
rsp_pub_y->len = (uint8_t)(public_key_len >> 1);
os_mem_cpy(rsp_pub_y->data, public_key + rsp_pub_x->len,
rsp_pub_y->len);
data += rsp_pub_y->len + sizeof(*rsp_pub_y);
rsp_r = (cert_test_sec_signature_r_t *)data;
rsp_r->len = (uint8_t)r_len;
os_mem_cpy(rsp_r->data, r, r_len);
data += r_len + sizeof(*rsp_r);
rsp_s = (cert_test_sec_signature_s_t *)data;
rsp_s->len = (uint8_t)r_len;
os_mem_cpy(rsp_s->data, s, s_len);
data += s_len + sizeof(*rsp_s);
iot_pkt_set_tail(rsp_pkt, data);
out:
if (reason) {
iot_printf("%s fail reason %lu\n", __FUNCTION__, reason);
}
return rsp_pkt;
}
static iot_pkt_t *mac_cert_test_sec_dsa_sign_verify(uint8_t is_sm2,
uint8_t *input, uint32_t len)
{
uint32_t ret;
uint8_t *data, reason = 0;
cert_test_sec_random_t *rand;
cert_test_sec_result_t *result;
cert_test_sec_signature_r_t *req_r;
cert_test_sec_signature_s_t *req_s;
cert_test_sec_public_key_x_t *rsp_pub_x, *rsp_pub_y;
iot_pkt_t *rsp_pkt = NULL;
uint8_t public_key[64];
uint32_t public_key_len;
/* downlink message layout is as follows:
* public key(x)
* public key(y)
* signature(r)
* signature(s)
* random
*/
data = input;
rsp_pub_x = (cert_test_sec_public_key_x_t *)data;
if ((rsp_pub_x->len + sizeof(*rsp_pub_x)) > len
|| !rsp_pub_x->len) {
reason = 1;
goto out;
}
len -= rsp_pub_x->len + sizeof(*rsp_pub_x);
data += rsp_pub_x->len + sizeof(*rsp_pub_x);
rsp_pub_x->len = min(32, rsp_pub_x->len);
rsp_pub_y = (cert_test_sec_public_key_x_t *)data;
if ((rsp_pub_y->len + sizeof(*rsp_pub_y)) > len
|| !rsp_pub_y->len) {
reason = 2;
goto out;
}
len -= rsp_pub_y->len + sizeof(*rsp_pub_y);
data += rsp_pub_y->len + sizeof(*rsp_pub_y);
rsp_pub_y->len = min(32, rsp_pub_y->len);
req_r = (cert_test_sec_signature_r_t *)data;
if ((req_r->len + sizeof(*req_r)) > len
|| !req_r->len) {
reason = 3;
goto out;
}
len -= req_r->len + sizeof(*req_r);
data += req_r->len + sizeof(*req_r);
req_r->len = min(32, req_r->len);
req_s = (cert_test_sec_signature_s_t *)data;
if ((req_s->len + sizeof(*req_s)) > len
|| !req_s->len) {
reason = 4;
goto out;
}
len -= req_s->len + sizeof(*req_s);
data += req_s->len + sizeof(*req_s);
req_s->len = min(32, req_s->len);
rand = (cert_test_sec_random_t *)data;
if ((rand->len + sizeof(*rand)) > len
|| !rand->len) {
reason = 5;
goto out;
}
os_mem_cpy(public_key, rsp_pub_x->data, rsp_pub_x->len);
os_mem_cpy(public_key + rsp_pub_x->len, rsp_pub_y->data,
rsp_pub_y->len);
public_key_len = rsp_pub_x->len + rsp_pub_y->len;
mac_cert_test_sec_data_dump("sign_verify_data:", rand->data,
(uint32_t)rand->len);
mac_cert_test_sec_data_dump("sign_r:", req_r->data, (uint32_t)req_r->len);
mac_cert_test_sec_data_dump("sign_s:", req_s->data, (uint32_t)req_s->len);
mac_cert_test_sec_data_dump("public_key:", public_key, public_key_len);
if (!is_sm2) {
ret = iot_crypto_ecdsa_with_sha256_sign_verify(ecdsa_ecp_bp256r1,
rand->data, rand->len, public_key, public_key_len, req_r->data,
(uint32_t)req_r->len, req_s->data, (uint32_t)req_s->len);
} else {
ret = iot_crypto_sm2_verify(rand->data, rand->len,
(uint8_t *)g_iot_sec_sm2_user_id, IOT_SEC_SM2_USER_ID_LEN,
public_key, public_key_len, req_r->data,
(uint32_t)req_r->len, req_s->data, (uint32_t)req_s->len);
}
len = sizeof(*result) + CERT_TEST_HDR_LEN;
rsp_pkt = iot_pkt_alloc(len, PLC_MAC_COMMON_MID);
if (!rsp_pkt) {
reason = 6;
goto out;
}
data = (uint8_t *)iot_pkt_data(rsp_pkt);
data += CERT_TEST_HDR_LEN;
result = (cert_test_sec_result_t *)data;
result->len = 1;
if (ret == ERR_OK) {
iot_printf("%s ok\n", __FUNCTION__);
result->value = 1;
} else {
iot_printf("%s fail\n", __FUNCTION__);
result->value = 0;
}
data += sizeof(*result);
iot_pkt_set_tail(rsp_pkt, data);
out:
if (reason) {
iot_printf("%s fail reason %lu\n", __FUNCTION__, reason);
}
return rsp_pkt;
}
iot_pkt_t *mac_cert_sec_cmd_parse(uint8_t cmd, uint8_t *src, uint32_t len)
{
uint8_t *data;
iot_pkt_t *ret_pkt = NULL;
#if CERT_TEST_DEBUG
iot_printf("sec_data. len:%lu\n", len);
mem_dump_byte(src, len);
#endif
#if SUPPORT_SMART_GRID
cert_test_t *cert_hdr = (cert_test_t *)src;
if (len < CERT_TEST_HDR_LEN) {
/* cert security data length error */
return ret_pkt;
}
if (cert_hdr->port != CERT_TEST_PORT_NOR
|| cert_hdr->id != CERT_TEST_ID_V
|| cert_test_is_mode_enter_cmd(cert_hdr)) {
return ret_pkt;
}
#else /* SUPPORT_SMART_GRID */
spg_cert_test_hdr_t *cert_hdr = (spg_cert_test_hdr_t *)src;
spg_cert_test_cmd_t *cert_cmd =
(spg_cert_test_cmd_t *)(src + sizeof(*cert_hdr));
spg_cert_test_dm_t *cert_dm =
(spg_cert_test_dm_t *)(src + sizeof(*cert_hdr) + sizeof(*cert_cmd));
if (len < CERT_TEST_HDR_LEN) {
/* cert security data length error */
return ret_pkt;
}
if (cert_hdr->port != SPG_CERT_TEST_PORT_NOR
|| cert_hdr->id != SPG_CERT_TEST_ID_V
|| cert_hdr->f_type != SPG_CERT_TEST_FRAME_TYPE
|| cert_cmd->test_id != SPG_CERT_TEST_ID_DUAL_MODE
|| cert_test_is_mode_enter_cmd_ext_spg(cert_dm)) {
return ret_pkt;
}
#endif /* SUPPORT_SMART_GRID */
#if MAC_CERT_SEC_ENCRYPT_WAR
uint8_t is_save_src_data;
switch (cmd) {
case CERT_TEST_SEC_MODE_AES_CBC_ENCRYPT:
case CERT_TEST_SEC_MODE_AES_GCM_ENCRYPT:
case CERT_TEST_SEC_MODE_SM4_CBC_ENCRYPT:
{
is_save_src_data = 0;
if (g_cert_sec_war_info.cur_cmd != cmd) {
if (NULL == g_cert_sec_war_info.src_pkt) {
g_cert_sec_war_info.src_pkt = iot_pkt_alloc(520,
PLC_MAC_COMMON_MID);
IOT_ASSERT(g_cert_sec_war_info.src_pkt);
}
if (NULL == g_cert_sec_war_info.rst_pkt) {
g_cert_sec_war_info.rst_pkt = iot_pkt_alloc(520,
PLC_MAC_COMMON_MID);
IOT_ASSERT(g_cert_sec_war_info.rst_pkt);
}
data = iot_pkt_data(g_cert_sec_war_info.src_pkt);
g_cert_sec_war_info.cur_cmd = cmd;
is_save_src_data = 1;
} else {
data = iot_pkt_data(g_cert_sec_war_info.src_pkt);
if ((iot_pkt_data_len(g_cert_sec_war_info.src_pkt) != len)
|| os_mem_cmp(src, data, len)) {
is_save_src_data = 1;
}
}
if (is_save_src_data) {
iot_pkt_set_tail(g_cert_sec_war_info.src_pkt, data + len);
os_mem_cpy(data, src, len);
g_cert_sec_war_info.is_sec_done = 0;
}
g_cert_sec_war_info.is_need_war = 1;
break;
}
default:
g_cert_sec_war_info.is_sec_done = 0;
g_cert_sec_war_info.is_need_war = 0;
break;
}
#endif
data = src + CERT_TEST_HDR_LEN;
len -= CERT_TEST_HDR_LEN;
switch (cmd) {
case CERT_TEST_SEC_MODE_SHA256:
{
ret_pkt = mac_cert_sec_sha256(data, len);
break;
}
case CERT_TEST_SEC_MODE_AES_CBC_ENCRYPT:
{
ret_pkt = mac_cert_sec_aes_cbc_encrypt(data, len);
break;
}
case CERT_TEST_SEC_MODE_AES_CBC_DECRYPT:
{
ret_pkt = mac_cert_sec_aes_cbc_decrypt(data, len);
break;
}
case CERT_TEST_SEC_MODE_SM3:
{
ret_pkt = mac_cert_test_sec_sm3(data, len);
break;
}
case CERT_TEST_SEC_MODE_ECC_SIG:
{
ret_pkt = mac_cert_test_sec_dsa_sign(0, data, len);
break;
}
case CERT_TEST_SEC_MODE_ECC_SIG_VERIFY:
{
ret_pkt = mac_cert_test_sec_dsa_sign_verify(0, data, len);
break;
}
case CERT_TEST_SEC_MODE_SM2_SIG:
{
ret_pkt = mac_cert_test_sec_dsa_sign(1, data, len);
break;
}
case CERT_TEST_SEC_MODE_SM2_SIG_VERIFY:
{
ret_pkt = mac_cert_test_sec_dsa_sign_verify(1, data, len);
break;
}
case CERT_TEST_SEC_MODE_AES_GCM_ENCRYPT:
{
ret_pkt = mac_cert_sec_aes_gcm_encrypt(data, len);
break;
}
case CERT_TEST_SEC_MODE_AES_GCM_DECRYPT:
{
ret_pkt = mac_cert_sec_aes_gcm_decrypt(data, len);
break;
}
case CERT_TEST_SEC_MODE_SM4_CBC_ENCRYPT:
{
ret_pkt = mac_cert_sec_sm4_cbc_encrypt(data, len);
break;
}
case CERT_TEST_SEC_MODE_SM4_CBC_DECRYPT:
{
ret_pkt = mac_cert_sec_sm4_cbc_decrypt(data, len);
break;
}
default:
//IOT_ASSERT(0);
break;
}
if (ret_pkt) {
#if SUPPORT_SMART_GRID
/* fill output pkt cert_test_t header */
cert_hdr = (cert_test_t *)iot_pkt_data(ret_pkt);
os_mem_cpy(cert_hdr, src, CERT_TEST_HDR_LEN);
cert_hdr->cmd_param = iot_pkt_data_len(ret_pkt) - CERT_TEST_HDR_LEN;
#else /* SUPPORT_SMART_GRID */
cert_hdr = (spg_cert_test_hdr_t *)iot_pkt_data(ret_pkt);
os_mem_cpy(cert_hdr, src, CERT_TEST_HDR_LEN);
cert_dm = (spg_cert_test_dm_t *)((uint8_t *)cert_hdr + sizeof(*cert_hdr)
+ sizeof(*cert_cmd));
cert_dm->cmd_param = iot_pkt_data_len(ret_pkt) - CERT_TEST_HDR_LEN;
#endif /* SUPPORT_SMART_GRID */
#if MAC_CERT_SEC_ENCRYPT_WAR
if (g_cert_sec_war_info.is_need_war
&& !g_cert_sec_war_info.is_sec_done) {
IOT_ASSERT(g_cert_sec_war_info.rst_pkt);
iot_pkt_cpy(g_cert_sec_war_info.rst_pkt, ret_pkt);
g_cert_sec_war_info.is_sec_done = 1;
mac_cert_test_sec_data_dump("sec_cmd_parse. backup",
iot_pkt_data(g_cert_sec_war_info.rst_pkt),
iot_pkt_data_len(g_cert_sec_war_info.rst_pkt));
//TODO: maybe need check timeout, then not return sec pkt
}
#endif
}
return ret_pkt;
}
#else /* MAC_CERT_SEC_SUPPORT */
iot_pkt_t *mac_cert_sec_cmd_parse(uint8_t cmd, uint8_t *src, uint32_t len)
{
(void)cmd;
(void)src;
(void)len;
iot_printf("%s not support\n", __FUNCTION__);
return NULL;
}
#endif /* MAC_CERT_SEC_SUPPORT */