From b396d4c09e734241b916a972b08f68f10250c003 Mon Sep 17 00:00:00 2001 From: zhao-zhen-zhou Date: Wed, 13 Oct 2021 21:39:53 +0800 Subject: [PATCH 01/12] =?UTF-8?q?=E6=93=8D=E4=BD=9C=E5=86=85=E5=AD=98?= =?UTF-8?q?=E5=89=8D=E5=A2=9E=E5=8A=A0=E5=86=85=E5=AD=98=E5=A4=A7=E5=B0=8F?= =?UTF-8?q?=E5=88=A4=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhao-zhen-zhou --- test/unittest/src/common/hks_test_aes.c | 1 + 1 file changed, 1 insertion(+) diff --git a/test/unittest/src/common/hks_test_aes.c b/test/unittest/src/common/hks_test_aes.c index 905c00ea..e0ecebda 100644 --- a/test/unittest/src/common/hks_test_aes.c +++ b/test/unittest/src/common/hks_test_aes.c @@ -579,6 +579,7 @@ int32_t TestAes256ByLocal() struct HksBlob plainText = { TEST_AES_256, tmp }; ret = HksDecrypt(&keyBlob, paramSet, &cipherText, &plainText); HKS_TEST_ASSERT(ret == 0); + HKS_TEST_ASSERT(plainText1.size == plainText.size); HKS_TEST_ASSERT(memcmp(plainText.data, plainText1.data, plainText.size) == 0); HksFreeParamSet(¶mSet); -- Gitee From 59092dafacc361deaabf7c64bb8bc58a08a98959 Mon Sep 17 00:00:00 2001 From: zmx <1029211721@qq.com> Date: Mon, 18 Oct 2021 15:04:08 +0800 Subject: [PATCH 02/12] samgr part name rectify Signed-off-by: zmx <1029211721@qq.com> Change-Id: I945e959dfe2a9f13c817f7c042c1e7d7a7368049 --- frameworks/huks_standard/main/os_dependency/BUILD.gn | 2 +- services/huks_standard/BUILD.gn | 2 +- services/huks_standard/huks_service/main/os_dependency/BUILD.gn | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/frameworks/huks_standard/main/os_dependency/BUILD.gn b/frameworks/huks_standard/main/os_dependency/BUILD.gn index 3524e363..aeacea81 100644 --- a/frameworks/huks_standard/main/os_dependency/BUILD.gn +++ b/frameworks/huks_standard/main/os_dependency/BUILD.gn @@ -50,7 +50,7 @@ ohos_static_library("libhuks_os_dependency_standard_static") { external_deps = [ "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", - "samgr_L2:samgr_proxy", + "samgr_standard:samgr_proxy", ] cflags_cc = [ "-DHILOG_ENABLE" ] cflags = [ "-DHILOG_ENABLE" ] diff --git a/services/huks_standard/BUILD.gn b/services/huks_standard/BUILD.gn index 1a56ab34..4b040eff 100755 --- a/services/huks_standard/BUILD.gn +++ b/services/huks_standard/BUILD.gn @@ -41,7 +41,7 @@ ohos_shared_library("huks_service") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", + "samgr_standard:samgr_proxy", ] } diff --git a/services/huks_standard/huks_service/main/os_dependency/BUILD.gn b/services/huks_standard/huks_service/main/os_dependency/BUILD.gn index a7867304..59fa2f4c 100644 --- a/services/huks_standard/huks_service/main/os_dependency/BUILD.gn +++ b/services/huks_standard/huks_service/main/os_dependency/BUILD.gn @@ -44,7 +44,7 @@ ohos_static_library("libhuks_service_os_dependency_standard_static") { "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", + "samgr_standard:samgr_proxy", ] complete_static_lib = true -- Gitee From 8e100cedc73b029062d38bf94e907a43fb03c6bd Mon Sep 17 00:00:00 2001 From: Vincentchenhao Date: Thu, 28 Oct 2021 14:39:43 +0800 Subject: [PATCH 03/12] add key attestation Signed-off-by: Vincentchenhao --- .../main/core/src/hks_client_check.c | 15 +++++ .../main/core/src/hks_client_service.c | 58 ++++++++++++++++++- .../idl/passthrough/hks_passthrough_access.c | 9 ++- 3 files changed, 79 insertions(+), 3 deletions(-) diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_check.c b/services/huks_standard/huks_service/main/core/src/hks_client_check.c index 06adaf57..be6a910c 100644 --- a/services/huks_standard/huks_service/main/core/src/hks_client_check.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_check.c @@ -165,3 +165,18 @@ int32_t HksCheckGenerateRandomParams(const struct HksBlob *processName, const st return HKS_SUCCESS; } +#ifdef HKS_SUPPORT_API_ATTEST_KEY +int32_t HksCheckAttestKeyParams(const struct HksBlob *processName, const struct HksBlob *keyAlias, + const struct HksParamSet *paramSet, struct HksBlob *certChain) +{ + return HksCheckGenAndImportKeyParams(processName, keyAlias, paramSet, certChain); +} +#endif + +#ifdef HKS_SUPPORT_API_GET_CERTIFICATE_CHAIN +int32_t HksCheckGetCertificateChainParams(const struct HksBlob *processName, const struct HksBlob *keyAlias, + const struct HksParamSet *paramSet, struct HksBlob *certChain) +{ + return HksCheckGenAndImportKeyParams(processName, keyAlias, paramSet, certChain); +} +#endif \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_service.c b/services/huks_standard/huks_service/main/core/src/hks_client_service.c index 4e4de694..51527c7e 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_client_service.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_service.c @@ -1220,13 +1220,67 @@ int32_t HksServiceSignWithDeviceKey(const struct HksBlob *processName, uint32_t int32_t HksServiceAttestKey(const struct HksBlob *processName, const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, struct HksBlob *certChain) { - return 0; +#ifdef HKS_SUPPORT_API_ATTEST_KEY + int32_t ret = HksCheckAttestKeyParams(processName, keyAlias, paramSet, certChain); + if (ret != HKS_SUCCESS) { + HKS_LOG_E(check attest key param fail); + return ret; + } + + struct HksParamSet *newParamSet = NULL; + struct HksBlob keyFromFile = { 0, NULL }; + ret = GetKeyAndNewParamSet(processName, keyAlias, paramSet, &keyFromFile, &newParamSet); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("GetKeyAndNewParamSet failed, ret = %d.", ret); + return ret; + } + + do { + ret = HksAccessAttestKey(&keyFromFile, newParamSet, certChain); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("HksAccessAttestKey fail, ret = %d.", ret); + break; + } + + ret = HksStoreKeyBlob(processName, keyAlias, HKS_STORAGE_TYPE_CERTCHAIN, certChain); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("store attest cert chain failed"); + } + } while (0); + + HKS_FREE_BLOB(keyFromFile); + HksFreeParamSet(&newParamSet) + return ret; +#else + return HKS_ERROR_NOT_SUPPORTED; +#endif } int32_t HksServiceGetCertificateChain(const struct HksBlob *processName, const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, struct HksBlob *certChain) { - return 0; +#ifdef HKS_SUPPORT_API_GET_CERTIFICATE_CHAIN + int32_t ret = HksCheckGetCertificateChainParams(processName, keyAlias, paramSet, certChain); + if (ret != HKS_SUCCESS) { + return ret; + } + + struct HksBlob certFromFile = { 0, NULL }; + ret = GetKeyData(processName, keyAlias, &certFromFile, HKS_STORAGE_TYPE_CERTCHAIN); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("HksGetKeyData fail, ret = %d.", ret); + return ret; + } + if (memcpy_s(certChain->data, certChain->size, certFromFile.data, certFromFile.size) != EOK) { + HKS_LOG_E("memcpy certChain fail."); + ret = HKS_ERROR_INSUFFICIENT_MEMORY; + } + certChain->size = certFromFile.size; + HKS_FREE_BLOB(certFromFile); + return ret; +#else + return HKS_ERROR_NOT_SUPPORTED; +#endif } int32_t HksServiceWrapKey(const struct HksBlob *processName, const struct HksBlob *keyAlias, diff --git a/services/huks_standard/huks_service/main/os_dependency/idl/passthrough/hks_passthrough_access.c b/services/huks_standard/huks_service/main/os_dependency/idl/passthrough/hks_passthrough_access.c index 507269db..f73b741f 100755 --- a/services/huks_standard/huks_service/main/os_dependency/idl/passthrough/hks_passthrough_access.c +++ b/services/huks_standard/huks_service/main/os_dependency/idl/passthrough/hks_passthrough_access.c @@ -136,4 +136,11 @@ int32_t HksAccessUpgradeKeyInfo(const struct HksBlob *keyAlias, const struct Hks int32_t HksAccessGenerateRandom(const struct HksParamSet *paramSet, struct HksBlob *random) { return HksCoreGenerateRandom(paramSet, random); -} \ No newline at end of file +} + +#ifdef HKS_SUPPORT_API_ATTEST_KEY +int32_t HksAccessAttestKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *certChain) +{ + return HKS_ERROR_NOT_SUPPORTED; +} +#endif \ No newline at end of file -- Gitee From a63e6ec9c932efc0831d4e2ab82dd187d92265db Mon Sep 17 00:00:00 2001 From: zhao-zhen-zhou Date: Wed, 3 Nov 2021 10:43:52 +0800 Subject: [PATCH 04/12] add an interface,determine whether there is device key. Signed-off-by: zhao-zhen-zhou --- interfaces/innerkits/huks_standard/main/include/hks_api.h | 2 ++ interfaces/innerkits/huks_standard/main/src/hks_api.c | 7 +++++++ 2 files changed, 9 insertions(+) diff --git a/interfaces/innerkits/huks_standard/main/include/hks_api.h b/interfaces/innerkits/huks_standard/main/include/hks_api.h index a9bf6f50..288ccf86 100755 --- a/interfaces/innerkits/huks_standard/main/include/hks_api.h +++ b/interfaces/innerkits/huks_standard/main/include/hks_api.h @@ -88,6 +88,8 @@ HKS_API_EXPORT int32_t HksUnwrapKey(const struct HksBlob *keyAlias, const struct HKS_API_EXPORT int32_t HksBnExpMod(struct HksBlob *x, const struct HksBlob *a, const struct HksBlob *e, const struct HksBlob *n); +HKS_API_EXPORT int32_t HcmIsDeviceKeyExist(const struct HksParamSet *paramSet); + #ifdef __cplusplus } #endif diff --git a/interfaces/innerkits/huks_standard/main/src/hks_api.c b/interfaces/innerkits/huks_standard/main/src/hks_api.c index 649596e9..ac70cf4c 100755 --- a/interfaces/innerkits/huks_standard/main/src/hks_api.c +++ b/interfaces/innerkits/huks_standard/main/src/hks_api.c @@ -568,3 +568,10 @@ HKS_API_EXPORT int32_t HksBnExpMod(struct HksBlob *x, const struct HksBlob *a, return HKS_ERROR_NOT_SUPPORTED; #endif } + +HKS_API_EXPORT int32_t HcmIsDeviceKeyExist(const struct HksParamSet *paramSet) +{ + (void)paramSet; + return HKS_ERROR_NOT_SUPPORTED; +} + -- Gitee From 14d8b8fb6e7cf75ece4b47a68045f3b915b28383 Mon Sep 17 00:00:00 2001 From: zhao-zhen-zhou Date: Mon, 15 Nov 2021 16:33:40 +0800 Subject: [PATCH 05/12] =?UTF-8?q?=E4=B8=8A=E4=BC=A0ca=E7=9A=84.c=E5=92=8C.?= =?UTF-8?q?h=E4=B8=A4=E4=B8=AA=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhao-zhen-zhou --- .../main/os_dependency/ca/hks_teec.c | 734 ++++++++++++++++++ .../main/os_dependency/ca/hks_teec.h | 87 +++ 2 files changed, 821 insertions(+) create mode 100755 services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c create mode 100755 services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c new file mode 100755 index 00000000..55710dc0 --- /dev/null +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c @@ -0,0 +1,734 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. + * Description: Provide TEEC functions. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#include "hks_teec.h" + +#include + +#include "hks_access.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "tee_client_api.h" +#include "tee_client_id.h" +#include "tee_client_type.h" + +#ifdef HKS_ROUTER +#define HISI_HKS_TA_PATH "/lib/sec/86310d18-5659-47c9-b212-841a3ca4f814.sec" +#else +#define HISI_HKS_TA_PATH "/vendor/bin/86310d18-5659-47c9-b212-841a3ca4f814.sec" +#endif + +#define MAX_TEE_PARAMS_NUMS 4 +#define PROVISION_PARAM_COUNT 4 + +#define TEE_SERVICE_HKS_TA \ +{ \ + 0x86310d18, \ + 0x5659, \ + 0x47c9, \ + { \ + 0xb2, 0x12, 0x84, 0x1a, 0x3c, 0xa4, 0xf8, 0x14 \ + } \ +} + +typedef struct { + enum TEEC_ParamType paramType; + uint32_t index; + union { + TEEC_TempMemoryReference tmpRef; + TEEC_Value value; + }; +} TeecOpParam; + +typedef struct { + TeecOpParam *params; + uint32_t length; +} TeecOpParamSet; + +typedef struct { + uint32_t paramTypes; + TeecOpParamSet paramSet; +} TeecOperation; + +static TEEC_Context *g_context = NULL; +static TEEC_Session *g_sessionSelfStart = NULL; + +static inline void InitializeBlob(struct HksBlob *blob, uint32_t size, uint8_t *data) +{ + if (blob != NULL) { + blob->data = data; + blob->size = size; + } +} + +static inline uint64_t Uint32To64(uint32_t high, uint32_t low) +{ + return ((uint64_t)(high) << 32) + (uint64_t)(low); /* 32 is higher bits */ +} + +static TEEC_Result TeecUuidInit(TEEC_Context *context, const char *taPath, + TEEC_UUID *uuid, const char *taName, uint32_t srcLen) +{ + if (!access(taPath, F_OK)) { + context->ta_path = (uint8_t *)taPath; + if (memcpy_s(uuid, sizeof(TEEC_UUID), taName, srcLen) != EOK) { + HKS_LOG_E("memcpy failed while copy ta name"); + return TEEC_ERROR_GENERIC; + } + + HKS_LOG_I("run on ta path:%s ", taPath); + return TEEC_SUCCESS; + } + + return TEEC_ERROR_GENERIC; +} + +static TEEC_Result OpenSession(TEEC_Context *context, TEEC_Session **session) +{ + TEEC_UUID uuid = { 0, 0, 0, { 0 } }; + TEEC_UUID uuidHisi = TEE_SERVICE_HKS_TA; + TEEC_Result ret = TeecUuidInit(context, HISI_HKS_TA_PATH, &uuid, (const char*)&uuidHisi, sizeof(TEEC_UUID)); + if (ret != TEEC_SUCCESS) { + HKS_LOG_E("ta uuid init failed!"); + return TEEC_ERROR_GENERIC; + } + + TEEC_Session *localSession = (TEEC_Session *)HksMalloc(sizeof(TEEC_Session)); + if (localSession == NULL) { + HKS_LOG_E("out of memory!"); + return (TEEC_Result)TEEC_ERROR_OUT_OF_MEMORY; + } + + TEEC_Operation operation; + + (void)memset_s(&operation, sizeof(operation), 0, sizeof(operation)); + operation.started = 1; + operation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_OUTPUT, TEEC_NONE, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT); + + uint32_t origin = 0; + ret = TEEC_OpenSession(context, localSession, &uuid, TEEC_LOGIN_IDENTIFY, NULL, &operation, &origin); + if (ret != TEEC_SUCCESS) { + HksFree(localSession); + HKS_LOG_E("open ta session failed, ret=0x%x, origin=%u", ret, origin); + return ret; + } + + *session = localSession; + HKS_LOG_I("Open Session success"); + return ret; +} + +static TEEC_Result TeecOpen(void) +{ + if (g_context != NULL) { + return TEEC_SUCCESS; + } + + g_context = HksMalloc(sizeof(TEEC_Context)); + if (g_context == NULL) { + HKS_LOG_E("memory allocate failed!"); + return TEEC_ERROR_OUT_OF_MEMORY; + } + + TEEC_Result result = TEEC_InitializeContext(NULL, g_context); + if (result != TEEC_SUCCESS) { + HKS_LOG_E("Initialize TEE context failed, ret=0x%x", result); + HKS_FREE_PTR(g_context); + return result; + } + + result = OpenSession(g_context, &g_sessionSelfStart); + if (result != TEEC_SUCCESS) { + TEEC_FinalizeContext(g_context); + HKS_FREE_PTR(g_context); + HKS_LOG_E("Open Session failed!"); + } + + return result; +} + +static void FillUpCommand(const TeecOpParam *src, TEEC_Parameter *des) +{ + switch (src->paramType) { + case TEEC_MEMREF_TEMP_INPUT: + case TEEC_MEMREF_TEMP_OUTPUT: + case TEEC_MEMREF_TEMP_INOUT: + des->tmpref.buffer = src->tmpRef.buffer; + des->tmpref.size = src->tmpRef.size; + break; + case TEEC_VALUE_INPUT: + case TEEC_VALUE_OUTPUT: + case TEEC_VALUE_INOUT: + des->value.a = src->value.a; + des->value.b = src->value.b; + break; + case TEEC_NONE: + break; + default: + break; + } +} + +static TEEC_Result TeecRequestCmdInner(enum HksCmdId pkiCmdId, TEEC_Operation *operation, + TeecOperation *teecOperation) +{ + TEEC_Result ret; + if (g_sessionSelfStart == NULL) { + ret = TeecOpen(); + if (ret != TEEC_SUCCESS) { + HKS_LOG_E("teec open failed!"); + return ret; + } + } + + if (memset_s(operation, sizeof(TEEC_Operation), 0, sizeof(TEEC_Operation)) != EOK) { + HKS_LOG_E("memset for operation failed!"); + return TEEC_ERROR_GENERIC; + } + + operation->started = 1; + operation->paramTypes = teecOperation->paramTypes; + + TeecOpParamSet paramSet = teecOperation->paramSet; + TeecOpParam *params = paramSet.params; + for (uint32_t i = 0; i < paramSet.length; i++) { + FillUpCommand(¶ms[i], &operation->params[params[i].index]); + } + + uint32_t retOrigin = 0; + ret = TEEC_InvokeCommand(g_sessionSelfStart, pkiCmdId, operation, &retOrigin); + if (ret != TEEC_SUCCESS) { + HKS_LOG_E("invoke km command failed, cmd = %u, ret = 0x%x, retOrigin = %u", pkiCmdId, ret, retOrigin); + } + + return ret; +} + +static void FillUpArgs(const struct HksParam *src, TeecOpParam *dest) +{ + switch (dest->paramType) { + case TEEC_MEMREF_TEMP_INPUT: + case TEEC_MEMREF_TEMP_OUTPUT: + case TEEC_MEMREF_TEMP_INOUT: + dest->tmpRef.buffer = src->blob.data; + dest->tmpRef.size = src->blob.size; + break; + case TEEC_VALUE_INPUT: + case TEEC_VALUE_OUTPUT: + case TEEC_VALUE_INOUT: + dest->value.a = (uint32_t)((src->uint64Param) >> 32); /* 32 is higher bits */ + dest->value.b = (uint32_t)(src->uint64Param); + break; + case TEEC_NONE: + break; + default: + break; + } +} + +static int32_t HksTeeCommand(uint32_t paramTypes, const struct HksParam params[MAX_TEE_PARAMS_NUMS], + uint32_t msgType, TEEC_Operation *operation) +{ + TeecOpParam opParams[MAX_TEE_PARAMS_NUMS]; + for (uint32_t i = 0; i < MAX_TEE_PARAMS_NUMS; ++i) { + opParams[i].index = i; + opParams[i].paramType = TEEC_PARAM_TYPE_GET(paramTypes, i); + FillUpArgs(¶ms[i], &opParams[i]); + } + + TeecOpParamSet teeParams = { + .params = opParams, + .length = MAX_TEE_PARAMS_NUMS + }; + TeecOperation teecOperation = { + .paramTypes = paramTypes, + .paramSet = teeParams + }; + + return TeecRequestCmdInner(msgType, operation, &teecOperation); +} + +int32_t HksTeeOpen(void) +{ + return TeecOpen(); +} + +#ifdef HKS_SUPPORT_API_INJECT_KEY +int32_t HksTeeProvision(const struct HksBlob *keybox, struct HksBlob *challenge, + const struct HksBlob *challengeIn, struct HksBlob *signature, struct HksBlob *certData) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, TEEC_MEMREF_TEMP_INOUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, keybox->size, keybox->data); + InitializeBlob(¶ms[1].blob, challenge->size, challenge->data); + InitializeBlob(¶ms[2].blob, signature->size, signature->data); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, certData->size, certData->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_INJECT_KEY, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command key provision failed"); + return ret; + } + + ret = ProvisionVerify(&operation, challengeIn, (PROVISION_PARAM_COUNT >> 1), NULL, false); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command HksTeeVerifyKeybox failed\n"); + } + + return ret; +} +#endif + +#ifdef HKS_SUPPORT_API_INJECT_KEY_VERIFY +int32_t HksTeeProvisionVerify(const struct HksBlob *verify, struct HksBlob *challenge, + const struct HksBlob *challengeIn, struct HksBlob *signature) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, TEEC_MEMREF_TEMP_INOUT, + TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, signature->size, signature->data); + InitializeBlob(¶ms[1].blob, challenge->size, challenge->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_INJECT_KEY_VERIFY, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command key provision verify failed"); + return ret; + } + + /* here we only have one key signature to verify, so the count is half of the provision param count */ + ret = ProvisionVerify(&operation, challengeIn, (PROVISION_PARAM_COUNT >> 1), verify, true); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("verify provision failed"); + } + + return ret; +} +#endif + +int32_t HksTeeGenerateKey(const struct HksBlob *keyBlob, const struct HksParamSet *paramSetIn, struct HksBlob *keyOut) +{ + uint8_t keyInBuffer[MAX_KEY_SIZE] = {0}; + struct HksBlob keyInBlob = { MAX_KEY_SIZE, keyInBuffer }; + const struct HksBlob *keyIn = &keyInBlob; + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, keyBlob->size, keyBlob->data); + InitializeBlob(¶ms[1].blob, paramSetIn->paramSetSize, (uint8_t *)paramSetIn); + InitializeBlob(¶ms[2].blob, keyIn->size, keyIn->data); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, keyOut->size, keyOut->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_GENERATE_KEY, &operation); + if (ret == HKS_SUCCESS) { + keyOut->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeCheckKeyLegality(const struct HksParamSet *paramSet, const struct HksBlob *key) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[1].blob, key->size, key->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_CHECK_KEY_LEGALITY, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command HksTeeCheckKeyLegality failed"); + } + + return ret; +} + +int32_t HksTeeGenerateRandom(const struct HksParamSet *paramSet, struct HksBlob *random) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[1].blob, random->size, random->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_GENERATE_RANDOM, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("command HksTeeGenerateRandom failed"); + } + + return ret; +} + +int32_t HksTeeImportKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *keyOut) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, key->size, key->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, keyOut->size, keyOut->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_IMPORT_KEY, &operation); + if (ret == HKS_SUCCESS) { + keyOut->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + + return ret; +} + +int32_t HksTeeExportPublicKey(const struct HksBlob *key, const struct HksParamSet *paramSet, + struct HksBlob *keyOut) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, key->size, key->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, keyOut->size, keyOut->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_EXPORT_KEY, &operation); + if (ret == HKS_SUCCESS) { + keyOut->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + + return ret; +} + +int32_t HksTeeAgreeKey(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, + const struct HksBlob *peerPublicKey, struct HksBlob *agreedKey) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[1].blob, privateKey->size, privateKey->data); + InitializeBlob(¶ms[2].blob, peerPublicKey->size, peerPublicKey->data); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, agreedKey->size, agreedKey->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_AGREE_KEY, &operation); + if (ret == HKS_SUCCESS) { + agreedKey->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeDeriveKey(const struct HksParamSet *paramSet, const struct HksBlob *kdfKey, struct HksBlob *derivedKey) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[1].blob, kdfKey->size, kdfKey->data); + InitializeBlob(¶ms[2].blob, derivedKey->size, derivedKey->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_DERIVE_KEY, &operation); + if (ret == HKS_SUCCESS) { + derivedKey->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + + return ret; +} + +int32_t HksTeeWrapKey(const struct HksBlob *wrapKey, const struct HksBlob *wrappedKey, + const struct HksParamSet *paramSet, struct HksBlob *wrappedData) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, wrapKey->size, wrapKey->data); + InitializeBlob(¶ms[1].blob, wrappedKey->size, wrappedKey->data); + InitializeBlob(¶ms[2].blob, paramSet->paramSetSize, (uint8_t *)paramSet); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, wrappedData->size, wrappedData->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_WRAP, &operation); + if (ret == HKS_SUCCESS) { + wrappedData->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeUnwrapKey(const struct HksBlob *wrapKey, const struct HksBlob *wrappedData, + const struct HksParamSet *paramSet, struct HksBlob *output) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, wrapKey->size, wrapKey->data); + InitializeBlob(¶ms[1].blob, wrappedData->size, wrappedData->data); + InitializeBlob(¶ms[2].blob, paramSet->paramSetSize, (uint8_t *)paramSet); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, output->size, output->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_UNWRAP, &operation); + if (ret == HKS_SUCCESS) { + output->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeAttestKey(const struct HksBlob *key, const struct HksParamSet *paramSet, + struct HksBlob *certChain) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, key->size, key->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, certChain->size, certChain->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_ATTEST_KEY, &operation); + if (ret == HKS_SUCCESS) { + certChain->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + + return ret; +} + +static bool IsVerify(uint32_t cmdId) +{ + return (cmdId == HKS_CMD_ID_VERIFY || cmdId == HKS_CMD_ID_VERIFY_FINAL); +} + +int32_t ProcessInit(uint32_t cmdId, const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + uint64_t *operationHandle) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_VALUE_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, keyBlob->size, keyBlob->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + params[2].uint64Param = 0; /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, cmdId, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("ProcessInit[%u] failed", cmdId); + return ret; + } + + *operationHandle = Uint32To64(operation.params[2].value.a, operation.params[2].value.b); /* 2 is array index */ + return ret; +} + +int32_t ProcessUpdate(uint32_t cmdId, uint64_t operationHandle, + const struct HksBlob *inData, const struct HksBlob *outData, bool isOutput) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_MEMREF_TEMP_INPUT, + (isOutput ? TEEC_MEMREF_TEMP_OUTPUT : TEEC_NONE), TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + params[0].uint64Param = operationHandle; + InitializeBlob(¶ms[1].blob, inData->size, inData->data); + + if (isOutput) { + InitializeBlob(¶ms[2].blob, outData->size, outData->data); /* 2 is array index */ + } else { + InitializeBlob(¶ms[2].blob, 0, NULL); /* 2 is array index */ + } + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, cmdId, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("ProcessUpdate[%u] failed", cmdId); + } + + return ret; +} + +int32_t ProcessFinal(uint32_t cmdId, uint64_t operationHandle, + const struct HksBlob *srcData, struct HksBlob *inOut, bool isInput) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_MEMREF_TEMP_INPUT, + isInput ? TEEC_MEMREF_TEMP_INPUT : TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + params[0].uint64Param = operationHandle; + InitializeBlob(¶ms[1].blob, srcData->size, srcData->data); + InitializeBlob(¶ms[2].blob, inOut->size, inOut->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, cmdId, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("ProcessFinal[%u] failed", cmdId); + return ret; + } + + if (!isInput) { + inOut->size = operation.params[2].tmpref.size; /* 2 is array index */ + } + return ret; +} + +int32_t ProcessOnce(uint32_t cmdId, const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *inOut) +{ + bool isInput = IsVerify(cmdId); + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + isInput ? TEEC_MEMREF_TEMP_INPUT : TEEC_MEMREF_TEMP_OUTPUT); + + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, keyBlob->size, keyBlob->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, srcData->size, srcData->data); /* 2 is array index */ + InitializeBlob(¶ms[3].blob, inOut->size, inOut->data); /* 3 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, cmdId, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("ProcessOnce[%u] failed", cmdId); + return ret; + } + + if (!isInput) { + inOut->size = operation.params[3].tmpref.size; /* 3 is array index */ + } + + return ret; +} + +int32_t HksTeeProcessInit(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, + uint64_t *operationHandle) +{ + return ProcessInit(cmdId, key, paramSet, operationHandle); +} + +int32_t HksTeeProcessMultiUpdate(uint32_t cmdId, uint64_t operationHandle, const struct HksBlob *inData, + struct HksBlob *outData) +{ + bool isOutput = (cmdId == HKS_CMD_ID_ENCRYPT_UPDATE) || (cmdId == HKS_CMD_ID_DECRYPT_UPDATE); + return ProcessUpdate(cmdId, operationHandle, inData, outData, isOutput); +} + +int32_t HksTeeSign(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *signature) +{ + return ProcessOnce(HKS_CMD_ID_SIGN, keyBlob, paramSet, srcData, signature); +} + +int32_t HksTeeVerify(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature) +{ + return ProcessOnce(HKS_CMD_ID_VERIFY, keyBlob, paramSet, srcData, (struct HksBlob *)signature); +} + +int32_t HksTeeMac(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *mac) +{ + return ProcessOnce(HKS_CMD_ID_MAC, keyBlob, paramSet, srcData, mac); +} + +int32_t HksTeeEncrypt(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *plainText, struct HksBlob *cipherText) +{ + return ProcessOnce(HKS_CMD_ID_ENCRYPT, keyBlob, paramSet, plainText, cipherText); +} + +int32_t HksTeeDecrypt(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *cipherText, struct HksBlob *plainText) +{ + return ProcessOnce(HKS_CMD_ID_DECRYPT, keyBlob, paramSet, cipherText, plainText); +} + +int32_t HksTeeExportTrustCerts(struct HksBlob *certChain) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, certChain->size, certChain->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_EXPORT_TRUST_CERT, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invoke HKS_CMD_ID_EXPORT_TRUST_CERT failed"); + return ret; + } + + certChain->size = operation.params[0].tmpref.size; + return ret; +} + +int32_t HksTeeImportTrustCerts(const struct HksBlob *certChain) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + InitializeBlob(¶ms[0].blob, certChain->size, certChain->data); + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_IMPORT_TRUST_CERT, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invoke HKS_CMD_ID_IMPORT_TRUST_CERT failed"); + return ret; + } + + return ret; +} + +#ifdef HKS_SUPPORT_API_EXPORT_DEVICE_PRI_KEY_MOD +int32_t HksTeeExportDevPriKey(const struct HksBlob *key, const struct HksParamSet *paramSet, + struct HksBlob *devPriKey) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, + TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS]; + + InitializeBlob(¶ms[0].blob, key->size, key->data); + InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); + InitializeBlob(¶ms[2].blob, devPriKey->size, devPriKey->data); /* 2 is array index */ + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_EXPORT_DEV_PRIVATE_KEY, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invoke HKS_CMD_ID_EXPORT_DEV_PRIVATE_KEY failed"); + return ret; + } + devPriKey->size = operation.params[2].tmpref.size; /* 2 is array index */ + return ret; +} +#endif + +#ifdef HKS_SUPPORT_API_DELETE_DEVICE_CERTS_MOD +int32_t HksTeeDeleteTrustCerts(void) +{ + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS] = {0}; + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_DELETE_TRUST_CERT, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invoke HKS_CMD_ID_DELETE_TRUST_CERT failed"); + } + return ret; +} +#endif + +int32_t HcmTeeIsDeviceKeyExist(void) +{ + HKS_LOG_D("enter"); + uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE); + struct HksParam params[MAX_TEE_PARAMS_NUMS] = {0}; + + TEEC_Operation operation; + int32_t ret = HksTeeCommand(paramTypes, params, HCM_CMD_ID_IS_DEVICE_KEY_EXIST, &operation); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("Invoke HCM_CMD_ID_IS_DEVICE_KEY_EXIST failed"); + } + return ret; +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h new file mode 100755 index 00000000..4b857bc1 --- /dev/null +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h @@ -0,0 +1,87 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. + * Description: Provide TEEC functions. + */ + +#ifndef HKS_TEEC_H +#define HKS_TEEC_H + +#include +#include "hks_type_inner.h" + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t HksTeeOpen(void); + +int32_t HksTeeGenerateKey(const struct HksBlob *keyBlob, const struct HksParamSet *paramSetIn, + struct HksBlob *keyOut); + +int32_t HksTeeProcessInit(uint32_t msgId, const struct HksBlob *key, const struct HksParamSet *paramSet, + uint64_t *operationHandle); + +int32_t HksTeeProcessMultiUpdate(uint32_t msgId, uint64_t operationHandle, const struct HksBlob *inData, + struct HksBlob *outData); + +int32_t HksTeeSign(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *signature); + +int32_t HksTeeVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature); + +int32_t HksTeeEncrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *plainText, struct HksBlob *cipherText); + +int32_t HksTeeDecrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *cipherText, struct HksBlob *plainText); + +int32_t HksTeeCheckKeyLegality(const struct HksParamSet *paramSet, const struct HksBlob *key); + +int32_t HksTeeGenerateRandom(const struct HksParamSet *paramSet, struct HksBlob *random); + +int32_t HksTeeImportKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *keyOut); + +int32_t HksTeeExportPublicKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *keyOut); + +int32_t HksTeeAgreeKey(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, + const struct HksBlob *peerPublicKey, struct HksBlob *agreedKey); + +int32_t HksTeeDeriveKey(const struct HksParamSet *paramSet, const struct HksBlob *kdfKey, struct HksBlob *derivedKey); + +int32_t HksTeeWrapKey(const struct HksBlob *keyAlias, const struct HksBlob *targetAlias, + const struct HksParamSet *paramSet, struct HksBlob *wrappedData); + +int32_t HksTeeUnwrapKey(const struct HksBlob *keyAlias, const struct HksBlob *wrappedData, + const struct HksParamSet *paramSet, struct HksBlob *output); + +int32_t HksTeeMac(const struct HksBlob *keyBlob, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *mac); + +int32_t HksTeeAttestKey(const struct HksBlob *key, const struct HksParamSet *paramSet, struct HksBlob *certChain); + +int32_t ProvisionVerify(TEEC_Operation *operation, const struct HksBlob *challengeIn, uint32_t certCount, + const struct HksBlob *verify, bool isVerify); + +int32_t HksTeeExportTrustCerts(struct HksBlob *certChain); + +int32_t HksTeeImportTrustCerts(const struct HksBlob *certChain); + +int32_t HksTeeExportDevPriKey(const struct HksBlob *key, const struct HksParamSet *paramSet, + struct HksBlob *devPriKey); + +int32_t HksTeeDeleteTrustCerts(void); + +int32_t HcmTeeIsDeviceKeyExist(void); + +int32_t HksTeeProvision(const struct HksBlob *keybox, struct HksBlob *challenge, + const struct HksBlob *challengeIn, struct HksBlob *signature, struct HksBlob *certData); + +int32_t HksTeeProvisionVerify(const struct HksBlob *verify, struct HksBlob *challenge, + const struct HksBlob *challengeIn, struct HksBlob *signature); + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file -- Gitee From 47ce98d6db1ceb22cf7ae0bf04685367b61b86b8 Mon Sep 17 00:00:00 2001 From: laokz <2653412+laokz@user.noreply.gitee.com> Date: Mon, 15 Nov 2021 11:31:11 +0000 Subject: [PATCH 06/12] =?UTF-8?q?fix(hks=5Ffile=5Foperator=5Flite):=20?= =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E5=88=9B=E5=BB=BA=E8=B7=AF=E5=BE=84=E7=9A=84?= =?UTF-8?q?=E9=BB=98=E8=AE=A4=E6=9D=83=E9=99=90=20=E6=96=B0=E5=BB=BA?= =?UTF-8?q?=E8=B7=AF=E5=BE=84=E7=9A=84=E9=BB=98=E8=AE=A4=E6=9D=83=E9=99=90?= =?UTF-8?q?=E7=94=B1rw-rw-rw=E4=BF=AE=E6=AD=A3=E4=B8=BArwx------=EF=BC=8C?= =?UTF-8?q?=20=E4=BB=A5=E6=94=AF=E6=8C=81=E7=9B=AE=E5=BD=95=E8=AE=BF?= =?UTF-8?q?=E9=97=AE=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: laokz --- .../main/os_dependency/posix/hks_file_operator_lite.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c index f4a7dd86..888929bc 100644 --- a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c +++ b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c @@ -29,7 +29,7 @@ #include /* use product definitions temporarily */ -#define DEFAULT_FILE_PERMISSION 0666 +#define DEFAULT_FILE_PERMISSION 0700 #else #include -- Gitee From 3611c54056ae4a790889aa71eb97d44debfa9c12 Mon Sep 17 00:00:00 2001 From: zhao-zhen-zhou Date: Tue, 16 Nov 2021 10:12:11 +0800 Subject: [PATCH 07/12] =?UTF-8?q?=E4=B8=8A=E4=BC=A0ca=E7=9A=84.c=E5=92=8C.?= =?UTF-8?q?h=E4=B8=A4=E4=B8=AA=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhao-zhen-zhou --- .../huks_service/main/os_dependency/ca/hks_teec.c | 14 ++++++++++++-- .../huks_service/main/os_dependency/ca/hks_teec.h | 14 ++++++++++++-- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c index 55710dc0..3e61c5f8 100755 --- a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c @@ -1,6 +1,16 @@ /* - * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. - * Description: Provide TEEC functions. + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. */ #ifdef HKS_CONFIG_FILE diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h index 4b857bc1..ad71a649 100755 --- a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h @@ -1,6 +1,16 @@ /* - * Copyright (c) Huawei Technologies Co., Ltd. 2020-2021. All rights reserved. - * Description: Provide TEEC functions. + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. */ #ifndef HKS_TEEC_H -- Gitee From fde6ae7b1562482f71d824c3b6856deab362f2b3 Mon Sep 17 00:00:00 2001 From: SryLideming Date: Thu, 11 Nov 2021 10:47:18 +0800 Subject: [PATCH 08/12] merge pr phase-2 Signed-off-by: SryLideming --- .gitattributes | 0 .vscode/settings.json | 5 + .../main/common/include/hks_base_check.h | 2 +- .../main/common/include/hks_check_paramset.h | 3 + .../main/common/include/hks_config.h | 6 - .../main/common/include/hks_config_base.h | 69 +- .../main/common/include/hks_crypto_hal.h | 8 + .../main/common/include/hks_type.h | 10 + .../main/common/src/hks_base_check.c | 275 +- .../main/common/src/hks_check_paramset.c | 93 +- .../main/common/src/hks_crypto_adapter.c | 154 +- .../main/core/src/hks_local_engine.c | 77 +- .../main/crypto_engine/mbedtls/BUILD.gn | 1 + .../mbedtls/include/hks_mbedtls_aes.h | 4 +- .../mbedtls/include/hks_mbedtls_dh.h | 51 + .../mbedtls/include/hks_mbedtls_dsa.h | 15 + .../mbedtls/include/hks_mbedtls_ecdsa.h | 7 +- .../mbedtls/include/hks_mbedtls_hmac.h | 2 + .../mbedtls/src/hks_mbedtls_aes.c | 18 + .../mbedtls/src/hks_mbedtls_common.c | 3 + .../mbedtls/src/hks_mbedtls_dh.c | 274 ++ .../mbedtls/src/hks_mbedtls_ecc.c | 5 +- .../mbedtls/src/hks_mbedtls_ecdh.c | 4 +- .../mbedtls/src/hks_mbedtls_ecdsa.c | 46 +- .../mbedtls/src/hks_mbedtls_engine.c | 38 +- .../mbedtls/src/hks_mbedtls_hash.c | 11 + .../mbedtls/src/hks_mbedtls_hmac.c | 2 + .../mbedtls/src/hks_mbedtls_rsa.c | 99 +- .../main/crypto_engine/openssl/BUILD.gn | 1 + .../openssl/include/hks_openssl_aes.h | 8 +- .../openssl/include/hks_openssl_dh.h | 44 + .../openssl/include/hks_openssl_dsa.h | 18 +- .../openssl/include/hks_openssl_ecc.h | 10 +- .../openssl/include/hks_openssl_engine.h | 2 +- .../openssl/include/hks_openssl_hmac.h | 14 +- .../openssl/include/hks_openssl_rsa.h | 20 +- .../openssl/src/hks_openssl_aes.c | 1 + .../openssl/src/hks_openssl_dh.c | 209 ++ .../openssl/src/hks_openssl_dsa.c | 169 +- .../openssl/src/hks_openssl_ecc.c | 66 +- .../openssl/src/hks_openssl_engine.c | 51 +- .../openssl/src/hks_openssl_hash.c | 2 + .../openssl/src/hks_openssl_hmac.c | 29 +- .../openssl/src/hks_openssl_rsa.c | 222 +- .../main/crypto_engine/test/unittest/BUILD.gn | 15 +- .../unittest/hks_crypto_hal_aes_cipher.cpp | 238 +- .../unittest/hks_crypto_hal_aes_decrypt.cpp | 183 +- .../unittest/hks_crypto_hal_aes_encrypt.cpp | 198 +- .../test/unittest/hks_crypto_hal_aes_key.cpp | 6 +- .../unittest/hks_crypto_hal_api_mbedtls.cpp | 234 +- .../unittest/hks_crypto_hal_api_openssl.cpp | 374 ++- .../test/unittest/hks_crypto_hal_dh.cpp | 86 + .../test/unittest/hks_crypto_hal_dh_agree.cpp | 155 ++ .../test/unittest/hks_crypto_hal_dsa_key.cpp | 8 +- .../test/unittest/hks_crypto_hal_dsa_sign.cpp | 297 +++ .../test/unittest/hks_crypto_hal_ecc_key.cpp | 14 +- .../unittest/hks_crypto_hal_ecdh_agree.cpp | 203 ++ .../unittest/hks_crypto_hal_ecdsa_sign.cpp | 1179 +++++++++ .../unittest/hks_crypto_hal_hmac_hmac.cpp | 192 ++ .../test/unittest/hks_crypto_hal_hmac_key.cpp | 2 +- .../unittest/hks_crypto_hal_rsa_cipher.cpp | 468 ++-- .../unittest/hks_crypto_hal_rsa_decrypt.cpp | 72 +- .../unittest/hks_crypto_hal_rsa_encrypt.cpp | 96 +- .../test/unittest/hks_crypto_hal_rsa_key.cpp | 18 +- .../hks_crypto_hal_rsa_oaep_decrypt.cpp | 216 +- .../hks_crypto_hal_rsa_oaep_encrypt.cpp | 288 +-- .../hks_crypto_hal_rsa_pkcs1_sign.cpp | 1947 +++++++++++++++ .../unittest/hks_crypto_hal_rsa_pss_sign.cpp | 1443 +++++++++++ .../huks_standard/main/include/hks_type.h | 5 + .../huks_standard/main/src/hks_api.c | 11 +- .../huks_standard/test/moduletest/BUILD.gn | 22 + .../include/hks_openssl_aes_test_mt.h | 7 +- .../include/hks_openssl_dh_mt_test.h | 54 + .../include/hks_openssl_dsa_sign_test_mt.h | 55 + .../include/hks_openssl_ecc_mt_test.h | 61 + .../include/hks_openssl_hmac_mt_test.h | 50 + .../include/hks_openssl_rsa_test_mt.h | 13 +- .../moduletest/src/hks_aes_cipher_mt_test.cpp | 540 ++-- .../src/hks_aes_decrypt_mt_test.cpp | 519 ++-- .../src/hks_aes_encrypt_mt_test.cpp | 519 ++-- .../moduletest/src/hks_aes_key_mt_test.cpp | 555 ++--- .../test/moduletest/src/hks_agree_mt_test.cpp | 1176 +++++++++ .../test/moduletest/src/hks_dsa_test_mt.cpp | 1730 +++++++++++++ .../moduletest/src/hks_ecc_key_mt_test.cpp | 1497 +++++++++++ .../moduletest/src/hks_ecc_sign_mt_test.cpp | 2217 +++++++++++++++++ .../moduletest/src/hks_ecc_verify_mt_test.cpp | 2194 ++++++++++++++++ .../test/moduletest/src/hks_hmac_mt_test.cpp | 740 ++++++ .../moduletest/src/hks_openssl_aes_test_mt.c | 9 - .../moduletest/src/hks_openssl_dh_mt_test.c | 259 ++ .../src/hks_openssl_dsa_sign_test_mt.c | 313 +++ .../moduletest/src/hks_openssl_ecc_mt_test.c | 594 +++++ .../moduletest/src/hks_openssl_hmac_mt_test.c | 65 + .../moduletest/src/hks_openssl_rsa_test_mt.c | 120 +- .../src/hks_rsa_ecb_nopadding_mt.cpp | 1109 +++++---- .../src/hks_rsa_ecb_oaep_padding_mt.cpp | 882 ++++--- .../src/hks_rsa_ecb_oaep_sha1_mt.cpp | 884 ++++--- .../src/hks_rsa_ecb_oaep_sha224_mt.cpp | 884 ++++--- .../src/hks_rsa_ecb_oaep_sha256_mt.cpp | 864 ++++--- .../src/hks_rsa_ecb_oaep_sha384_mt.cpp | 848 ++++--- .../src/hks_rsa_ecb_oaep_sha512_mt.cpp | 836 ++++--- .../src/hks_rsa_ecb_pkcs1_padding_mt.cpp | 884 ++++--- .../src/hks_rsa_md5_with_rsa_mt.cpp | 1596 ++++++++++++ .../src/hks_rsa_none_with_rsa_mt.cpp | 1596 ++++++++++++ .../src/hks_rsa_sha1_with_rsa_mt.cpp | 1596 ++++++++++++ .../src/hks_rsa_sha1_with_rsa_pss_mt.cpp | 1596 ++++++++++++ .../src/hks_rsa_sha224_with_rsa_mt.cpp | 1596 ++++++++++++ .../src/hks_rsa_sha224_with_rsa_pss_mt.cpp | 1596 ++++++++++++ .../src/hks_rsa_sha256_with_rsa_mt.cpp | 1596 ++++++++++++ .../src/hks_rsa_sha256_with_rsa_pss_mt.cpp | 1596 ++++++++++++ .../src/hks_rsa_sha384_with_rsa_mt.cpp | 1584 ++++++++++++ .../src/hks_rsa_sha384_with_rsa_pss_mt.cpp | 1604 ++++++++++++ .../src/hks_rsa_sha512_with_rsa_mt.cpp | 1584 ++++++++++++ .../src/hks_rsa_sha512_with_rsa_pss_mt.cpp | 1592 ++++++++++++ interfaces/kits/js/@ohos.security.huks.d.ts | 11 +- interfaces/kits/napi/BUILD.gn | 9 + .../kits/napi/include/huks_napi_agree_key.h | 26 + .../kits/napi/include/huks_napi_attest_key.h | 26 + .../kits/napi/include/huks_napi_common.h | 10 +- .../kits/napi/include/huks_napi_delete_key.h | 2 +- .../kits/napi/include/huks_napi_derive_key.h | 26 + .../kits/napi/include/huks_napi_encrypt.h | 2 +- .../kits/napi/include/huks_napi_export_key.h | 2 +- .../include/huks_napi_get_certificate_chain.h | 26 + .../kits/napi/include/huks_napi_import_key.h | 2 +- .../napi/include/huks_napi_is_key_exist.h | 2 +- interfaces/kits/napi/include/huks_napi_mac.h | 26 + interfaces/kits/napi/include/huks_napi_sign.h | 26 + .../kits/napi/include/huks_napi_unwrap_key.h | 26 + .../kits/napi/include/huks_napi_verify.h | 26 + .../kits/napi/include/huks_napi_wrap_key.h | 26 + interfaces/kits/napi/src/huks_napi.cpp | 32 +- .../kits/napi/src/huks_napi_agree_key.cpp | 247 ++ .../kits/napi/src/huks_napi_attest_key.cpp | 219 ++ interfaces/kits/napi/src/huks_napi_common.cpp | 118 +- .../kits/napi/src/huks_napi_decrypt.cpp | 28 +- .../kits/napi/src/huks_napi_delete_key.cpp | 24 +- .../kits/napi/src/huks_napi_derive_key.cpp | 220 ++ .../kits/napi/src/huks_napi_encrypt.cpp | 30 +- .../kits/napi/src/huks_napi_export_key.cpp | 24 +- .../kits/napi/src/huks_napi_generate_key.cpp | 24 +- .../src/huks_napi_get_certificate_chain.cpp | 222 ++ .../napi/src/huks_napi_get_key_properties.cpp | 30 +- .../kits/napi/src/huks_napi_import_key.cpp | 28 +- .../kits/napi/src/huks_napi_is_key_exist.cpp | 24 +- interfaces/kits/napi/src/huks_napi_mac.cpp | 246 ++ interfaces/kits/napi/src/huks_napi_sign.cpp | 245 ++ .../kits/napi/src/huks_napi_unwrap_key.cpp | 251 ++ interfaces/kits/napi/src/huks_napi_verify.cpp | 257 ++ .../kits/napi/src/huks_napi_wrap_key.cpp | 233 ++ .../main/core/src/hks_core_service.c | 17 +- .../main/core/include/hks_storage_file_lock.h | 1 - .../main/core/src/hks_client_service.c | 4 +- .../core/src/hks_client_service_adapter.c | 147 +- .../os_dependency/posix/hks_file_operator.c | 8 +- .../posix/hks_file_operator_lite.c | 5 + 155 files changed, 46634 insertions(+), 6052 deletions(-) mode change 100644 => 100755 .gitattributes create mode 100755 .vscode/settings.json create mode 100755 frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dh.h create mode 100755 frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dh.c create mode 100755 frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dh.h create mode 100755 frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c create mode 100755 frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp create mode 100755 frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp create mode 100755 frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp create mode 100755 frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp create mode 100755 frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp create mode 100755 frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp create mode 100755 frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pkcs1_sign.cpp create mode 100755 frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pss_sign.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dh_mt_test.h create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dsa_sign_test_mt.h create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_ecc_mt_test.h create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_hmac_mt_test.h create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_test_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dh_mt_test.c create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dsa_sign_test_mt.c create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_ecc_mt_test.c create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_hmac_mt_test.c create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp create mode 100755 interfaces/kits/napi/include/huks_napi_agree_key.h create mode 100755 interfaces/kits/napi/include/huks_napi_attest_key.h create mode 100755 interfaces/kits/napi/include/huks_napi_derive_key.h create mode 100755 interfaces/kits/napi/include/huks_napi_get_certificate_chain.h create mode 100755 interfaces/kits/napi/include/huks_napi_mac.h create mode 100755 interfaces/kits/napi/include/huks_napi_sign.h create mode 100755 interfaces/kits/napi/include/huks_napi_unwrap_key.h create mode 100755 interfaces/kits/napi/include/huks_napi_verify.h create mode 100755 interfaces/kits/napi/include/huks_napi_wrap_key.h create mode 100755 interfaces/kits/napi/src/huks_napi_agree_key.cpp create mode 100755 interfaces/kits/napi/src/huks_napi_attest_key.cpp create mode 100755 interfaces/kits/napi/src/huks_napi_derive_key.cpp create mode 100755 interfaces/kits/napi/src/huks_napi_get_certificate_chain.cpp create mode 100755 interfaces/kits/napi/src/huks_napi_mac.cpp create mode 100755 interfaces/kits/napi/src/huks_napi_sign.cpp create mode 100755 interfaces/kits/napi/src/huks_napi_unwrap_key.cpp create mode 100755 interfaces/kits/napi/src/huks_napi_verify.cpp create mode 100755 interfaces/kits/napi/src/huks_napi_wrap_key.cpp diff --git a/.gitattributes b/.gitattributes old mode 100644 new mode 100755 diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100755 index 00000000..47aeff71 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "files.associations": { + "hks_config.h": "c" + } +} \ No newline at end of file diff --git a/frameworks/huks_standard/main/common/include/hks_base_check.h b/frameworks/huks_standard/main/common/include/hks_base_check.h index 12577d0b..d048dad2 100644 --- a/frameworks/huks_standard/main/common/include/hks_base_check.h +++ b/frameworks/huks_standard/main/common/include/hks_base_check.h @@ -82,7 +82,7 @@ int32_t HksCheckGenKeyMutableParams(uint32_t alg, const struct ParamsValues *inp int32_t CheckImportMutableParams(uint32_t alg, const struct ParamsValues *params); -int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, const struct HksBlob *key, const struct HksBlob *signature); +int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, uint32_t keySize, const struct HksBlob *signature); int32_t HksCheckSignVerifyMutableParams(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams); diff --git a/frameworks/huks_standard/main/common/include/hks_check_paramset.h b/frameworks/huks_standard/main/common/include/hks_check_paramset.h index 8da25cc1..cd680497 100755 --- a/frameworks/huks_standard/main/common/include/hks_check_paramset.h +++ b/frameworks/huks_standard/main/common/include/hks_check_paramset.h @@ -38,6 +38,9 @@ int32_t HksCoreCheckCipherParams(uint32_t cmdId, const struct HksBlob *key, cons int32_t HksCoreCheckAgreeKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, const struct HksBlob *peerPublicKey, const struct HksBlob *agreedKey, bool isLocalCheck); +int32_t HksLocalCheckSignVerifyParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature); + int32_t HksLocalCheckCipherParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, const struct HksBlob *inData, const struct HksBlob *outData); diff --git a/frameworks/huks_standard/main/common/include/hks_config.h b/frameworks/huks_standard/main/common/include/hks_config.h index a6aaadec..6d0b682c 100644 --- a/frameworks/huks_standard/main/common/include/hks_config.h +++ b/frameworks/huks_standard/main/common/include/hks_config.h @@ -93,12 +93,6 @@ #define HKS_SUPPORT_RSA_ECB_OEAPPADDING #define HKS_SUPPORT_RSA_PSS -/* DH */ -#define HKS_SUPPORT_DH_C -#define HKS_SUPPORT_DH_GENERATE_KEY -#define HKS_SUPPORT_DH_AGREE_KEY -#define HKS_SUPPORT_DH_GET_PUBLIC_KEY - /* DSA */ #define HKS_SUPPORT_DSA_C #define HKS_SUPPORT_DSA_GENERATE_KEY diff --git a/frameworks/huks_standard/main/common/include/hks_config_base.h b/frameworks/huks_standard/main/common/include/hks_config_base.h index 301f5333..5899baa5 100644 --- a/frameworks/huks_standard/main/common/include/hks_config_base.h +++ b/frameworks/huks_standard/main/common/include/hks_config_base.h @@ -27,6 +27,9 @@ #define HKS_SUPPORT_AES_CBC_PKCS7 #define HKS_SUPPORT_AES_GCM #define HKS_SUPPORT_AES_CCM +#define HKS_SUPPORT_AES_CTR_NOPADDING +#define HKS_SUPPORT_AES_ECB_NOPADDING +#define HKS_SUPPORT_AES_ECB_PKCS7PADDING /* BN */ #define HKS_SUPPORT_BN_C @@ -35,8 +38,16 @@ #define HKS_SUPPORT_ECC_C #define HKS_SUPPORT_ECC_GENERATE_KEY #define HKS_SUPPORT_ECC_GET_PUBLIC_KEY + #define HKS_SUPPORT_ECDH_C +#define HKS_SUPPORT_ECDH_GENERATE_KEY +#define HKS_SUPPORT_ECDH_AGREE_KEY +#define HKS_SUPPORT_ECDH_GET_PUBLIC_KEY + #define HKS_SUPPORT_ECDSA_C +#define HKS_SUPPORT_ECDSA_GENERATE_KEY +#define HKS_SUPPORT_ECDSA_SIGN_VERIFY +#define HKS_SUPPORT_EDDSA_GET_PUBLIC_KEY /* ED25519 */ #define HKS_SUPPORT_ED25519_C @@ -46,9 +57,21 @@ /* HASH */ #define HKS_SUPPORT_HASH_C +#define HKS_SUPPORT_HASH_SHA1 +#define HKS_SUPPORT_HASH_SHA224 +#define HKS_SUPPORT_HASH_SHA256 +#define HKS_SUPPORT_HASH_SHA384 +#define HKS_SUPPORT_HASH_SHA512 +#define HKS_SUPPORT_HASH_MD5 /* HMAC */ #define HKS_SUPPORT_HMAC_C +#define HKS_SUPPORT_HMAC_GENERATE_KEY +#define HKS_SUPPORT_HMAC_SHA1 +#define HKS_SUPPORT_HMAC_SHA224 +#define HKS_SUPPORT_HMAC_SHA256 +#define HKS_SUPPORT_HMAC_SHA384 +#define HKS_SUPPORT_HMAC_SHA512 /* KDF */ #define HKS_SUPPORT_KDF_C @@ -61,6 +84,27 @@ #define HKS_SUPPORT_RSA_CRYPT #define HKS_SUPPORT_RSA_SIGN_VERIFY #define HKS_SUPPORT_RSA_GET_PUBLIC_KEY +#define HKS_SUPPORT_RSA_ECB_NOPADDING +#define HKS_SUPPORT_RSA_ECB_PKCS1PADDING +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA1MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA224MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA256MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA384MGF1 +#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA512MGF1 +#define HKS_SUPPORT_RSA_ECB_OEAPPADDING +#define HKS_SUPPORT_RSA_PSS + +/* DH */ +#define HKS_SUPPORT_DH_C +#define HKS_SUPPORT_DH_GENERATE_KEY +#define HKS_SUPPORT_DH_AGREE_KEY +#define HKS_SUPPORT_DH_GET_PUBLIC_KEY + +/* DSA */ +#define HKS_SUPPORT_DSA_C +#define HKS_SUPPORT_DSA_GENERATE_KEY +#define HKS_SUPPORT_DSA_SIGN_VERIFY +#define HKS_SUPPORT_DSA_GET_PUBLIC_KEY /* X25519 */ #define HKS_SUPPORT_X25519_C @@ -70,30 +114,33 @@ #define HKS_SUPPORT_ED25519_TO_X25519 -#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ - defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_RSA_GENERATE_KEY) || \ - defined(HKS_SUPPORT_X25519_GENERATE_KEY) +#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_DH_GENERATE_KEY) || \ + defined(HKS_SUPPORT_DSA_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ + defined(HKS_SUPPORT_ECDH_GENERATE_KEY) || defined(HKS_SUPPORT_ECDSA_GENERATE_KEY) || \ + defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_HMAC_GENERATE_KEY) || \ + defined(HKS_SUPPORT_RSA_GENERATE_KEY) || defined(HKS_SUPPORT_X25519_GENERATE_KEY) #define HKS_SUPPORT_API_GENERATE_KEY #define HKS_SUPPORT_API_DELETE_KEY #define HKS_SUPPORT_API_GET_KEY_PARAM_SET #define HKS_SUPPORT_API_KEY_EXIST #endif -#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ - defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) || \ - defined(HKS_SUPPORT_AES_C) +#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ + defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) #define HKS_SUPPORT_API_IMPORT #endif -#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ - defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) +#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ + defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) #define HKS_SUPPORT_API_EXPORT #endif #define HKS_SUPPORT_API_GENERATE_RANDOM -#if defined(HKS_SUPPORT_ECDSA_C) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ - defined(HKS_SUPPORT_RSA_SIGN_VERIFY) +#if defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ + defined(HKS_SUPPORT_RSA_SIGN_VERIFY) || defined(HKS_SUPPORT_DSA_SIGN_VERIFY) #define HKS_SUPPORT_API_SIGN_VERIFY #endif @@ -101,7 +148,7 @@ #define HKS_SUPPORT_API_CIPHER #endif -#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_C) +#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_AGREE_KEY) || defined(HKS_SUPPORT_DH_AGREE_KEY) #define HKS_SUPPORT_API_AGREE_KEY #endif diff --git a/frameworks/huks_standard/main/common/include/hks_crypto_hal.h b/frameworks/huks_standard/main/common/include/hks_crypto_hal.h index 9366b612..a6a3a217 100755 --- a/frameworks/huks_standard/main/common/include/hks_crypto_hal.h +++ b/frameworks/huks_standard/main/common/include/hks_crypto_hal.h @@ -98,6 +98,14 @@ struct KeyMaterialDsa { uint32_t gSize; }; +struct KeyMaterialDh { + enum HksKeyAlg keyAlg; + uint32_t keySize; + uint32_t pubKeySize; + uint32_t priKeySize; + uint32_t reserved; +}; + struct KeyMaterial25519 { enum HksKeyAlg keyAlg; uint32_t keySize; diff --git a/frameworks/huks_standard/main/common/include/hks_type.h b/frameworks/huks_standard/main/common/include/hks_type.h index c099426c..dc081e34 100755 --- a/frameworks/huks_standard/main/common/include/hks_type.h +++ b/frameworks/huks_standard/main/common/include/hks_type.h @@ -90,6 +90,7 @@ enum HksKeyPurpose { HKS_KEY_PURPOSE_WRAP = 32, /* Usable with wrap key. */ HKS_KEY_PURPOSE_UNWRAP = 64, /* Usable with unwrap key. */ HKS_KEY_PURPOSE_MAC = 128, /* Usable with mac. */ + HKS_KEY_PURPOSE_AGREE = 256, /* Usable with agree. */ }; enum HksKeyDigest { @@ -139,6 +140,10 @@ enum HksKeySize { HKS_AES_KEY_SIZE_512 = 512, HKS_CURVE25519_KEY_SIZE_256 = 256, + + HKS_DH_KEY_SIZE_2048 = 2048, + HKS_DH_KEY_SIZE_3072 = 3072, + HKS_DH_KEY_SIZE_4096 = 4096, }; enum HksKeyAlg { @@ -410,6 +415,11 @@ struct HksPubKeyInfo { uint32_t placeHolder; }; +struct HksKeyMaterialHeader { + enum HksKeyAlg keyAlg; + uint32_t keySize; +}; + #define HKS_DERIVE_DEFAULT_SALT_LEN 16 #define HKS_HMAC_DIGEST_SHA512_LEN 64 #define HKS_DEFAULT_RANDOM_LEN 16 diff --git a/frameworks/huks_standard/main/common/src/hks_base_check.c b/frameworks/huks_standard/main/common/src/hks_base_check.c index 75117288..b26a0ca7 100755 --- a/frameworks/huks_standard/main/common/src/hks_base_check.c +++ b/frameworks/huks_standard/main/common/src/hks_base_check.c @@ -55,11 +55,12 @@ static uint32_t g_rsaKeySize[] = { }; static uint32_t g_rsaPadding[] = { HKS_PADDING_NONE, - HKS_PADDING_PSS, HKS_PADDING_OAEP, + HKS_PADDING_PSS, HKS_PADDING_PKCS1_V1_5 }; static uint32_t g_rsaDigest[] = { + HKS_DIGEST_MD5, HKS_DIGEST_NONE, HKS_DIGEST_SHA1, HKS_DIGEST_SHA224, @@ -69,10 +70,11 @@ static uint32_t g_rsaDigest[] = { }; static uint32_t g_rsaSignPadding[] = { HKS_PADDING_PSS, + HKS_PADDING_PKCS1_V1_5 }; static uint32_t g_rsaCipherPadding[] = { - HKS_PADDING_OAEP, HKS_PADDING_NONE, + HKS_PADDING_OAEP, HKS_PADDING_PKCS1_V1_5 }; #endif @@ -173,6 +175,13 @@ static uint32_t g_dsaDigest[] = { HKS_DIGEST_SHA512 }; #endif +#ifdef HKS_SUPPORT_DH_C +static uint32_t g_dhKeySize[] = { + HKS_DH_KEY_SIZE_2048, + HKS_DH_KEY_SIZE_3072, + HKS_DH_KEY_SIZE_4096 +}; +#endif #ifdef HKS_SUPPORT_RSA_C static const struct ParamsValuesChecker g_rsaParamSet[] = { @@ -352,6 +361,120 @@ static const struct ExpectParamsValuesChecker g_expectDsaParams[] = { }; #endif +#ifdef HKS_SUPPORT_DH_C +static const struct ParamsValuesChecker g_dhParamSet[] = { + { HKS_CHECK_TYPE_GEN_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { false, 0 }, { false, 0 } } }, + { HKS_CHECK_TYPE_USE_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { false, 0 }, { false, 0 } } } +}; +static const struct ExpectParamsValuesChecker g_expectDhParams[] = { + { HKS_CHECK_TYPE_GEN_KEY, { + { true, g_dhKeySize, sizeof(g_dhKeySize) / sizeof(g_dhKeySize[0]) }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 } + } + }, + { HKS_CHECK_TYPE_USE_KEY, { + { true, g_dhKeySize, sizeof(g_dhKeySize) / sizeof(g_dhKeySize[0]) }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 } + } + } +}; +#endif + +#ifdef HKS_SUPPORT_ECDH_C +static const struct ParamsValuesChecker g_ecdhParamSet[] = { + { HKS_CHECK_TYPE_GEN_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { false, 0 }, { false, 0 } } }, + { HKS_CHECK_TYPE_USE_KEY, { { true, 0 }, { false, 0 }, { true, 0 }, { false, 0 }, { false, 0 } } } +}; +static const struct ExpectParamsValuesChecker g_expectEcdhParams[] = { + { HKS_CHECK_TYPE_GEN_KEY, { + { true, g_ecdhKeySize, sizeof(g_ecdhKeySize) / sizeof(g_ecdhKeySize[0]) }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 } + } + }, + { HKS_CHECK_TYPE_USE_KEY, { + { true, g_ecdhKeySize, sizeof(g_ecdhKeySize) / sizeof(g_ecdhKeySize[0]) }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 }, + { false, NULL, 0 } + } + } +}; +#endif + +static uint32_t INVALID_PURPOSE[][2] = { +#ifdef HKS_SUPPORT_RSA_C + { + HKS_ALG_RSA, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_AGREE, + }, +#endif +#ifdef HKS_SUPPORT_ECC_C + { + HKS_ALG_ECC, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + }, +#endif +#ifdef HKS_SUPPORT_AES_C + { + HKS_ALG_AES, + HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_AGREE, + }, +#endif +#ifdef HKS_SUPPORT_ED25519_C + { + HKS_ALG_ED25519, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + }, +#endif +#ifdef HKS_SUPPORT_X25519_C + { + HKS_ALG_X25519, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + }, +#endif +#ifdef HKS_SUPPORT_HMAC_C + { + HKS_ALG_HMAC, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_WRAP | + HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE, + }, +#endif +#ifdef HKS_SUPPORT_DSA_C + { + HKS_ALG_DSA, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_AGREE, + }, +#endif +#ifdef HKS_SUPPORT_DH_C + { + HKS_ALG_DH, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, +#endif +#ifdef HKS_SUPPORT_ECDH_C + { + HKS_ALG_ECDH, + HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | + HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, +#endif +}; + #ifndef _CUT_AUTHENTICATE_ #ifndef _STORAGE_LITE_ static int32_t CheckAndGetKeySize(const struct HksBlob *key, const uint32_t *expectKeySize, @@ -413,64 +536,44 @@ static int32_t CheckPurposeUnique(uint32_t inputPurpose) uint32_t purposeDerive = inputPurpose & HKS_KEY_PURPOSE_DERIVE; uint32_t purposeWrap = inputPurpose & (HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP); uint32_t purposeMac = inputPurpose & HKS_KEY_PURPOSE_MAC; + uint32_t purposeAgree = inputPurpose & HKS_KEY_PURPOSE_AGREE; uint32_t purposeCount = (purposeCipher != 0) ? 1 : 0; purposeCount += (purposeSign != 0) ? 1 : 0; purposeCount += (purposeDerive != 0) ? 1 : 0; purposeCount += (purposeWrap != 0) ? 1 : 0; purposeCount += (purposeMac != 0) ? 1 : 0; + purposeCount += (purposeAgree != 0) ? 1 : 0; return (purposeCount == 1) ? HKS_SUCCESS : HKS_ERROR_INVALID_PURPOSE; } +static int32_t GetInvalidPurpose(uint32_t alg, uint32_t *inputPurpose) +{ + int32_t result = HKS_ERROR_INVALID_ALGORITHM; + if (sizeof(INVALID_PURPOSE) == 0) { + return result; + } + uint32_t count = sizeof(INVALID_PURPOSE) / sizeof(INVALID_PURPOSE[0]); + for (uint32_t i = 0; i < count; i++) { + if (alg == INVALID_PURPOSE[i][0]) { + result = HKS_SUCCESS; + *inputPurpose = INVALID_PURPOSE[i][1]; + break; + } + } + return result; +} + static int32_t CheckPurposeValid(uint32_t alg, uint32_t inputPurpose) { uint32_t invalidPurpose = 0; - switch (alg) { -#ifdef HKS_SUPPORT_RSA_C - case HKS_ALG_RSA: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | - HKS_KEY_PURPOSE_UNWRAP; - break; -#endif -#ifdef HKS_SUPPORT_ECC_C - case HKS_ALG_ECC: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | - HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT; - break; -#endif -#ifdef HKS_SUPPORT_AES_C - case HKS_ALG_AES: - invalidPurpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY; - break; -#endif -#ifdef HKS_SUPPORT_ED25519_C - case HKS_ALG_ED25519: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | - HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT; - break; -#endif -#ifdef HKS_SUPPORT_X25519_C - case HKS_ALG_X25519: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | - HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT; - break; -#endif -#ifdef HKS_SUPPORT_HMAC_C - case HKS_ALG_HMAC: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY | - HKS_KEY_PURPOSE_WRAP | HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT; - break; -#endif -#ifdef HKS_SUPPORT_DSA_C - case HKS_ALG_DSA: - invalidPurpose = HKS_KEY_PURPOSE_DERIVE | HKS_KEY_PURPOSE_MAC | HKS_KEY_PURPOSE_WRAP | - HKS_KEY_PURPOSE_UNWRAP | HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT; - break; -#endif - default: - return HKS_ERROR_INVALID_ALGORITHM; + + uint32_t result = GetInvalidPurpose(alg, &invalidPurpose); + if (result != HKS_SUCCESS) { + return result; } + if ((inputPurpose & invalidPurpose) != 0) { return HKS_ERROR_INVALID_PURPOSE; } @@ -573,7 +676,15 @@ static int32_t InitInputParamsByAlg(uint32_t alg, enum CheckKeyType checkType, s #endif #ifdef HKS_SUPPORT_DSA_C case HKS_ALG_DSA: - return InitInputParams(checkType, inputParams, g_dsaParamSet, HKS_ARRAY_SIZE(g_hmacParamSet)); + return InitInputParams(checkType, inputParams, g_dsaParamSet, HKS_ARRAY_SIZE(g_dsaParamSet)); +#endif +#ifdef HKS_SUPPORT_DH_C + case HKS_ALG_DH: + return InitInputParams(checkType, inputParams, g_dhParamSet, HKS_ARRAY_SIZE(g_dhParamSet)); +#endif +#ifdef HKS_SUPPORT_ECDH_C + case HKS_ALG_ECDH: + return InitInputParams(checkType, inputParams, g_ecdhParamSet, HKS_ARRAY_SIZE(g_ecdhParamSet)); #endif default: return HKS_ERROR_INVALID_ALGORITHM; @@ -624,6 +735,14 @@ static int32_t GetExpectParams(uint32_t alg, enum CheckKeyType checkType, struct #ifdef HKS_SUPPORT_DSA_C case HKS_ALG_DSA: return InitExpectParams(checkType, expectValues, g_expectDsaParams, HKS_ARRAY_SIZE(g_expectDsaParams)); +#endif +#ifdef HKS_SUPPORT_DH_C + case HKS_ALG_DH: + return InitExpectParams(checkType, expectValues, g_expectDhParams, HKS_ARRAY_SIZE(g_expectDhParams)); +#endif +#ifdef HKS_SUPPORT_ECDH_C + case HKS_ALG_ECDH: + return InitExpectParams(checkType, expectValues, g_expectEcdhParams, HKS_ARRAY_SIZE(g_expectEcdhParams)); #endif default: return HKS_ERROR_INVALID_ALGORITHM; @@ -1037,6 +1156,31 @@ int32_t HksCheckGenKeyPurpose(uint32_t alg, uint32_t inputPurpose) return CheckPurposeValid(alg, inputPurpose); } +static int32_t HksGetDsaKeySize(const struct HksBlob *key, uint32_t *keySize) + +{ + if (key->size < sizeof(struct HksParamSet)) { + HKS_LOG_E("check key size: invalid keyfile size: %u", key->size); + return HKS_ERROR_INVALID_KEY_FILE; + } + + struct HksParamSet *keyParamSet = (struct HksParamSet *)key->data; + int32_t ret = HksCheckParamSetValidity(keyParamSet); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check key size: paramset invalid failed"); + return HKS_ERROR_INVALID_KEY_FILE; + } + + struct HksParam *keySizeParam = NULL; + ret = HksGetParam(keyParamSet, HKS_TAG_KEY_SIZE, &keySizeParam); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check key size: get param get tag:0x%x failed", HKS_TAG_KEY_SIZE); + return HKS_ERROR_INVALID_KEY_FILE; + } + *keySize = keySizeParam->uint32Param; + return ret; +} + int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize) { switch (alg) { @@ -1044,6 +1188,14 @@ int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize case HKS_ALG_RSA: return CheckAndGetKeySize(key, g_rsaKeySize, HKS_ARRAY_SIZE(g_rsaKeySize), keySize); #endif +#ifdef HKS_SUPPORT_DSA_C + case HKS_ALG_DSA: +#ifndef _STORAGE_LITE_ + return HksGetDsaKeySize(key, keySize); +#else + return HKS_ERROR_INVALID_ALGORITHM; +#endif +#endif #ifdef HKS_SUPPORT_ECC_C case HKS_ALG_ECC: return CheckAndGetKeySize(key, g_eccKeySize, HKS_ARRAY_SIZE(g_eccKeySize), keySize); @@ -1056,6 +1208,10 @@ int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize case HKS_ALG_X25519: case HKS_ALG_ED25519: return CheckAndGetKeySize(key, g_curve25519KeySize, HKS_ARRAY_SIZE(g_curve25519KeySize), keySize); +#endif +#ifdef HKS_SUPPORT_DH_C + case HKS_ALG_DH: + return CheckAndGetKeySize(key, g_dhKeySize, HKS_ARRAY_SIZE(g_dhKeySize), keySize); #endif default: return HKS_ERROR_INVALID_ALGORITHM; @@ -1199,20 +1355,17 @@ int32_t CheckImportMutableParams(uint32_t alg, const struct ParamsValues *params return HKS_SUCCESS; } -int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, const struct HksBlob *key, const struct HksBlob *signature) +int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, uint32_t keySize, const struct HksBlob *signature) { - uint32_t keySize = 0; - int32_t ret = HksGetKeySize(alg, key, &keySize); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("get keySize failed!"); - return ret; - } - switch (alg) { -#if defined(HKS_SUPPORT_RSA_C) && defined (HKS_SUPPORT_RSA_SIGN_VERIFY) +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) case HKS_ALG_RSA: return CheckRsaSignature(cmdId, keySize, signature); #endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY) + case HKS_ALG_DSA: + return HKS_SUCCESS; +#endif #ifdef HKS_SUPPORT_ECC_C case HKS_ALG_ECC: return CheckEccSignature(cmdId, keySize, signature); @@ -1251,6 +1404,14 @@ int32_t HksCheckSignVerifyMutableParams(uint32_t cmdId, uint32_t alg, const stru return HKS_ERROR_INVALID_PADDING; } break; +#endif +#ifdef HKS_SUPPORT_DSA_C + case HKS_ALG_DSA: + break; +#endif +#ifdef HKS_SUPPORT_ECC_C + case HKS_ALG_ECC: + break; #endif default: /* other alg no need check padding */ @@ -1302,7 +1463,7 @@ int32_t HksCheckCihperData(uint32_t cmdId, uint32_t alg, const struct ParamsValu const struct HksBlob *inData, const struct HksBlob *outData) { switch (alg) { -#if defined(HKS_SUPPORT_RSA_C) && defined (HKS_SUPPORT_RSA_CRYPT) +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_CRYPT) case HKS_ALG_RSA: return CheckRsaCipherData(cmdId, inputParams, inData, outData); #endif diff --git a/frameworks/huks_standard/main/common/src/hks_check_paramset.c b/frameworks/huks_standard/main/common/src/hks_check_paramset.c index 6fcac63d..2ad51bde 100755 --- a/frameworks/huks_standard/main/common/src/hks_check_paramset.c +++ b/frameworks/huks_standard/main/common/src/hks_check_paramset.c @@ -60,6 +60,12 @@ static uint32_t g_genKeyAlg[] = { #ifdef HKS_SUPPORT_DSA_C HKS_ALG_DSA, #endif +#ifdef HKS_SUPPORT_DH_C + HKS_ALG_DH, +#endif +#ifdef HKS_SUPPORT_ECDH_C + HKS_ALG_ECDH, +#endif }; static uint32_t g_importKeyAlg[] = { @@ -96,6 +102,9 @@ static uint32_t g_signAlg[] = { #ifdef HKS_SUPPORT_RSA_C HKS_ALG_RSA, #endif +#ifdef HKS_SUPPORT_DSA_C + HKS_ALG_DSA, +#endif #ifdef HKS_SUPPORT_ECC_C HKS_ALG_ECC, #endif @@ -112,12 +121,21 @@ static uint32_t g_agreeAlg[] = { #ifdef HKS_SUPPORT_X25519_C HKS_ALG_X25519, #endif +#ifdef HKS_SUPPORT_DH_C + HKS_ALG_DH, +#endif }; static uint32_t g_agreeAlgLocal[] = { +#ifdef HKS_SUPPORT_ECDH_C + HKS_ALG_ECDH, +#endif #ifdef HKS_SUPPORT_X25519_C HKS_ALG_X25519, #endif +#ifdef HKS_SUPPORT_DH_C + HKS_ALG_DH, +#endif }; #endif /* _CUT_AUTHENTICATE_ */ @@ -137,12 +155,18 @@ static uint32_t g_deriveAlgLocal[] = { }; static uint32_t g_digest[] = { + HKS_DIGEST_SHA1, + HKS_DIGEST_SHA224, HKS_DIGEST_SHA256, HKS_DIGEST_SHA384, HKS_DIGEST_SHA512 }; static uint32_t g_macDigest[] = { - HKS_DIGEST_SHA256 + HKS_DIGEST_SHA1, + HKS_DIGEST_SHA224, + HKS_DIGEST_SHA256, + HKS_DIGEST_SHA384, + HKS_DIGEST_SHA512, }; #ifdef HKS_SUPPORT_AES_C static uint32_t g_aesKeySizeLocal[] = { @@ -457,7 +481,14 @@ int32_t HksCoreCheckSignVerifyParams(uint32_t cmdId, const struct HksBlob *key, return ret; } - ret = HksCheckSignature(cmdId, alg, key, signature); + uint32_t keySize = 0; + ret = HksGetKeySize(alg, key, &keySize); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get keySize failed!"); + return ret; + } + + ret = HksCheckSignature(cmdId, alg, keySize, signature); if (ret != HKS_SUCCESS) { HKS_LOG_E("check signature failed, ret = %d", ret); } @@ -473,6 +504,49 @@ int32_t HksCoreCheckSignVerifyParams(uint32_t cmdId, const struct HksBlob *key, #endif } +int32_t HksLocalCheckSignVerifyParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature) +{ +#ifdef HKS_SUPPORT_API_SIGN_VERIFY + (void)srcData; + uint32_t alg; + int32_t ret = CheckAndGetAlgorithm(paramSet, g_signAlg, HKS_ARRAY_SIZE(g_signAlg), &alg); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check and get alg failed"); + return ret; + } + + struct ParamsValues params; + (void)memset_s(¶ms, sizeof(params), 0, sizeof(params)); + + ret = HksGetInputParmasByAlg(alg, HKS_CHECK_TYPE_USE_KEY, paramSet, ¶ms); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("sign or verify get input params failed, ret = %d", ret); + return ret; + } + + ret = CheckSignVerifyParamsByAlg(cmdId, alg, ¶ms); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("sign or verify check params failed, ret = %d", ret); + return ret; + } + + ret = HksCheckSignature(cmdId, alg, keySize, signature); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check signature failed, ret = %d", ret); + } + + return ret; +#else + (void)cmdId; + (void)keySize; + (void)paramSet; + (void)srcData; + (void)signature; + return HKS_ERROR_NOT_SUPPORTED; +#endif +} + int32_t HksCoreCheckAgreeKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, const struct HksBlob *peerPublicKey, const struct HksBlob *agreedKey, bool isLocalCheck) { @@ -491,11 +565,18 @@ int32_t HksCoreCheckAgreeKeyParams(const struct HksParamSet *paramSet, const str uint32_t keySize = 0; if (isLocalCheck) { - if ((privateKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256)) || - (peerPublicKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256))) { - return HKS_ERROR_INVALID_KEY_SIZE; + if (alg == HKS_ALG_ED25519) { + if ((privateKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256)) || + (peerPublicKey->size != HKS_KEY_BYTES(HKS_CURVE25519_KEY_SIZE_256))) { + return HKS_ERROR_INVALID_KEY_SIZE; + } + } + + if (alg == HKS_ALG_DH || alg == HKS_ALG_ECC || alg == HKS_ALG_ECDH) { + keySize = ((struct HksKeyMaterialHeader *)privateKey->data)->keySize; + } else if (alg == HKS_ALG_ED25519) { + keySize = privateKey->size * HKS_BITS_PER_BYTE; } - keySize = privateKey->size * HKS_BITS_PER_BYTE; } else { ret = HksGetKeySize(alg, privateKey, &keySize); if (ret != HKS_SUCCESS) { diff --git a/frameworks/huks_standard/main/common/src/hks_crypto_adapter.c b/frameworks/huks_standard/main/common/src/hks_crypto_adapter.c index 3d5de19b..0cf012eb 100755 --- a/frameworks/huks_standard/main/common/src/hks_crypto_adapter.c +++ b/frameworks/huks_standard/main/common/src/hks_crypto_adapter.c @@ -360,11 +360,12 @@ static int32_t FormatCurve25519Key(const struct HksBlob *keyIn, struct HksParamS struct HksParam params[] = { { .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, - .blob = {keyMaterial->pubKeySize, keyIn->data + sizeof(struct KeyMaterial25519)}, + .blob = { keyMaterial->pubKeySize, keyIn->data + sizeof(struct KeyMaterial25519) }, }, { .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, - .blob = {keyMaterial->priKeySize, keyIn->data + sizeof(struct KeyMaterial25519) + keyMaterial->pubKeySize}, + .blob = { keyMaterial->priKeySize, + keyIn->data + sizeof(struct KeyMaterial25519) + keyMaterial->pubKeySize }, }, }; @@ -409,7 +410,7 @@ static int32_t FormatAesKey(const struct HksBlob *keyIn, struct HksParamSet *par struct HksParam params[] = { { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = {keyIn->size, keyIn->data}, + .blob = { keyIn->size, keyIn->data }, }, }; return BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); @@ -419,6 +420,10 @@ static int32_t FormatAesKey(const struct HksBlob *keyIn, struct HksParamSet *par #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) static int32_t FormatRsaKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) { + if (keyIn->size < sizeof(struct KeyMaterialRsa)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)keyIn->data; uint32_t publicKeySize = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize; if (keyIn->size < publicKeySize) { @@ -432,17 +437,17 @@ static int32_t FormatRsaKey(const struct HksBlob *keyIn, struct HksParamSet *par return HKS_ERROR_MALLOC_FAIL; } - memcpy_s(publicKey, publicKeySize, keyIn->data, publicKeySize); + (void)memcpy_s(publicKey, publicKeySize, keyIn->data, publicKeySize); ((struct KeyMaterialRsa *)publicKey)->dSize = 0; struct HksParam params[] = { { .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, - .blob = {publicKeySize, publicKey}, + .blob = { publicKeySize, publicKey }, }, { .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, - .blob = {keyIn->size, keyIn->data}, + .blob = { keyIn->size, keyIn->data }, }, }; int32_t ret = BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); @@ -458,7 +463,7 @@ static int32_t FormatHmacKey(const struct HksBlob *keyIn, struct HksParamSet *pa struct HksParam params[] = { { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = {keyIn->size, keyIn->data}, + .blob = { keyIn->size, keyIn->data }, }, }; return BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); @@ -466,86 +471,47 @@ static int32_t FormatHmacKey(const struct HksBlob *keyIn, struct HksParamSet *pa #endif #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) -static void DivideDsaKey(const struct HksBlob *keyIn, struct HksBlob *pubKey, struct HksBlob *priKey) -{ - struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)keyIn->data; - uint32_t inOffset = 0; - uint32_t outOffset = 0; - - memcpy_s(pubKey->data + outOffset, pubKey->size - outOffset, keyIn->data + inOffset, sizeof(struct KeyMaterialDsa)); - inOffset += sizeof(struct KeyMaterialDsa); - outOffset += sizeof(struct KeyMaterialDsa); - inOffset += keyMaterial->xSize; - memcpy_s(pubKey->data + outOffset, pubKey->size - outOffset, keyIn->data + inOffset, keyMaterial->ySize); - inOffset += keyMaterial->ySize; - outOffset += keyMaterial->ySize; - memcpy_s(pubKey->data + outOffset, pubKey->size - outOffset, keyIn->data + inOffset, keyMaterial->pSize); - inOffset += keyMaterial->pSize; - outOffset += keyMaterial->pSize; - memcpy_s(pubKey->data + outOffset, pubKey->size - outOffset, keyIn->data + inOffset, keyMaterial->qSize); - inOffset += keyMaterial->qSize; - outOffset += keyMaterial->qSize; - memcpy_s(pubKey->data + outOffset, pubKey->size - outOffset, keyIn->data + inOffset, keyMaterial->gSize); - ((struct KeyMaterialDsa *)pubKey->data)->xSize = 0; - - inOffset = 0; - outOffset = 0; - memcpy_s(priKey->data + outOffset, priKey->size - outOffset, keyIn->data + inOffset, sizeof(struct KeyMaterialDsa)); - inOffset += sizeof(struct KeyMaterialDsa); - outOffset += sizeof(struct KeyMaterialDsa); - memcpy_s(priKey->data + outOffset, priKey->size - outOffset, keyIn->data + inOffset, keyMaterial->xSize); - inOffset += keyMaterial->xSize; - outOffset += keyMaterial->xSize; - inOffset += keyMaterial->ySize; - memcpy_s(priKey->data + outOffset, priKey->size - outOffset, keyIn->data + inOffset, keyMaterial->pSize); - inOffset += keyMaterial->pSize; - outOffset += keyMaterial->pSize; - memcpy_s(priKey->data + outOffset, priKey->size - outOffset, keyIn->data + inOffset, keyMaterial->qSize); - inOffset += keyMaterial->qSize; - outOffset += keyMaterial->qSize; - memcpy_s(priKey->data + outOffset, priKey->size - outOffset, keyIn->data + inOffset, keyMaterial->gSize); - ((struct KeyMaterialDsa *)pubKey->data)->ySize = 0; -} - static int32_t FormatDsaKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) { + if (keyIn->size < sizeof(struct KeyMaterialDsa)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)keyIn->data; uint32_t publicKeySize = sizeof(struct KeyMaterialDsa) + keyMaterial->ySize + keyMaterial->pSize + keyMaterial->qSize + keyMaterial->gSize; - uint32_t privateKeySize = sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + keyMaterial->pSize + - keyMaterial->qSize + keyMaterial->gSize; - if (keyIn->size < publicKeySize || keyIn->size < privateKeySize) { + if (keyIn->size < publicKeySize) { HKS_LOG_E("invalid key info."); return HKS_ERROR_INVALID_KEY_INFO; } uint8_t *publicKey = (uint8_t *)HksMalloc(publicKeySize); - uint8_t *privateKey = (uint8_t *)HksMalloc(privateKeySize); - if (publicKey == NULL || privateKey == NULL) { + if (publicKey == NULL) { HKS_LOG_E("malloc key failed."); HKS_FREE_PTR(publicKey); - HKS_FREE_PTR(privateKey); return HKS_ERROR_MALLOC_FAIL; } + (void)memcpy_s(publicKey, publicKeySize, keyIn->data, sizeof(struct KeyMaterialDsa)); + uint32_t inOffset = sizeof(struct KeyMaterialDsa); + uint32_t outOffset = sizeof(struct KeyMaterialDsa) + keyMaterial->xSize; + (void)memcpy_s(publicKey + inOffset, publicKeySize - inOffset, keyIn->data + outOffset, publicKeySize - inOffset); + ((struct KeyMaterialDsa *)publicKey)->xSize = 0; + struct HksParam params[] = { { .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, - .blob = {publicKeySize, publicKey}, + .blob = { publicKeySize, publicKey }, }, { .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, - .blob = {privateKeySize, privateKey}, + .blob = { keyIn->size, keyIn->data }, }, }; - DivideDsaKey(keyIn, ¶ms[0].blob, ¶ms[1].blob); - int32_t ret = BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); memset_s(publicKey, publicKeySize, 0x00, publicKeySize); - memset_s(privateKey, privateKeySize, 0x00, privateKeySize); HksFree(publicKey); - HksFree(privateKey); return ret; } #endif @@ -553,6 +519,10 @@ static int32_t FormatDsaKey(const struct HksBlob *keyIn, struct HksParamSet *par #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) static int32_t FormatEccKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) { + if (keyIn->size < sizeof(struct KeyMaterialEcc)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)keyIn->data; uint32_t publicKeySize = sizeof(struct KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; if (keyIn->size < publicKeySize) { @@ -566,17 +536,57 @@ static int32_t FormatEccKey(const struct HksBlob *keyIn, struct HksParamSet *par return HKS_ERROR_MALLOC_FAIL; } - memcpy_s(publicKey, publicKeySize, keyIn->data, publicKeySize); + (void)memcpy_s(publicKey, publicKeySize, keyIn->data, publicKeySize); ((struct KeyMaterialEcc *)publicKey)->zSize = 0; struct HksParam params[] = { { .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, - .blob = {publicKeySize, publicKey}, + .blob = { publicKeySize, publicKey }, + }, + { + .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, + .blob = { keyIn->size, keyIn->data }, + }, + }; + int32_t ret = BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); + memset_s(publicKey, publicKeySize, 0x00, publicKeySize); + HksFree(publicKey); + return ret; +} +#endif + +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY) +static int32_t FormatDhKey(const struct HksBlob *keyIn, struct HksParamSet *paramSetOut) +{ + if (keyIn->size < sizeof(struct KeyMaterialDh)) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)keyIn->data; + uint32_t publicKeySize = sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize; + if (keyIn->size < publicKeySize) { + HKS_LOG_E("invalid key info."); + return HKS_ERROR_INVALID_KEY_INFO; + } + + uint8_t *publicKey = (uint8_t *)HksMalloc(publicKeySize); + if (publicKey == NULL) { + HKS_LOG_E("malloc public key failed."); + return HKS_ERROR_MALLOC_FAIL; + } + + (void)memcpy_s(publicKey, publicKeySize, keyIn->data, publicKeySize); + ((struct KeyMaterialDh *)publicKey)->priKeySize = 0; + + struct HksParam params[] = { + { + .tag = HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, + .blob = { publicKeySize, publicKey }, }, { .tag = HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, - .blob = {keyIn->size, keyIn->data}, + .blob = { keyIn->size, keyIn->data }, }, }; int32_t ret = BuildParamSetOut(params, HKS_ARRAY_SIZE(params), paramSetOut); @@ -592,6 +602,19 @@ int32_t HksSetKeyToMaterial(uint32_t alg, bool isPubKey, const struct HksBlob *k case HKS_ALG_X25519: case HKS_ALG_ED25519: return SetCurve25519KeyMaterial(isPubKey, key, keyMaterial); + case HKS_ALG_RSA: + case HKS_ALG_DSA: + case HKS_ALG_ECC: + case HKS_ALG_ECDH: + case HKS_ALG_DH: + keyMaterial->size = key->size; + keyMaterial->data = HksMalloc(keyMaterial->size); + if (keyMaterial->data != NULL) { + (void)memcpy_s(keyMaterial->data, keyMaterial->size, key->data, key->size); + return HKS_SUCCESS; + } else { + return HKS_ERROR_MALLOC_FAIL; + } default: HKS_LOG_E("alg not support"); return HKS_ERROR_INVALID_ALGORITHM; @@ -634,7 +657,12 @@ int32_t HksFormatKeyFromMaterial(uint32_t alg, const struct HksBlob *keyMaterial #endif #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) case HKS_ALG_ECC: + case HKS_ALG_ECDH: return FormatEccKey(keyMaterial, paramSetOut); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY) + case HKS_ALG_DH: + return FormatDhKey(keyMaterial, paramSetOut); #endif default: HKS_LOG_E("alg not support"); diff --git a/frameworks/huks_standard/main/core/src/hks_local_engine.c b/frameworks/huks_standard/main/core/src/hks_local_engine.c index 62810280..be5937bb 100755 --- a/frameworks/huks_standard/main/core/src/hks_local_engine.c +++ b/frameworks/huks_standard/main/core/src/hks_local_engine.c @@ -281,41 +281,83 @@ int32_t HksLocalDeriveKey(const struct HksParamSet *paramSet, const struct HksBl } #ifndef _CUT_AUTHENTICATE_ -static int32_t CheckLocalVerifyParams(const struct HksBlob *key, const struct HksParamSet *paramSet, +static int32_t CheckLocalSignVerifyParams(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, const struct HksBlob *srcData, const struct HksBlob *signature) { if (HksCheckBlob3AndParamSet(key, srcData, signature, paramSet) != HKS_SUCCESS) { return HKS_ERROR_INVALID_ARGUMENT; } - if (key->size != (HKS_CURVE25519_KEY_SIZE_256 / HKS_BITS_PER_BYTE)) { - HKS_LOG_E("invalid key size: %u", key->size); - return HKS_ERROR_INVALID_KEY_SIZE; + struct HksParam *algParam = NULL; + int32_t ret = HksGetParam(paramSet, HKS_TAG_ALGORITHM, &algParam); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get param algorithm failed"); + return HKS_ERROR_CHECK_GET_ALG_FAIL; } - if (signature->size < HKS_SIGNATURE_MIN_SIZE) { - HKS_LOG_E("signature size too small, size: %u", signature->size); - return HKS_ERROR_INVALID_SIGNATURE_SIZE; + uint32_t keySize = 0; + if (algParam->uint32Param == HKS_ALG_RSA) { + keySize = ((struct KeyMaterialRsa *)key->data)->keySize; + } else if (algParam->uint32Param == HKS_ALG_DSA) { + keySize = ((struct KeyMaterialDsa *)key->data)->keySize; + } else if (algParam->uint32Param == HKS_ALG_ECC) { + keySize = ((struct KeyMaterialEcc *)key->data)->keySize; + } else if (algParam->uint32Param == HKS_ALG_ED25519) { + keySize = key->size * HKS_BITS_PER_BYTE; } - struct HksParam *purposeParam = NULL; - int32_t ret = HksGetParam(paramSet, HKS_TAG_PURPOSE, &purposeParam); + ret = HksLocalCheckSignVerifyParams(cmdId, keySize, paramSet, srcData, signature); if (ret != HKS_SUCCESS) { - HKS_LOG_E("get param purpose failed"); - return HKS_ERROR_CHECK_GET_PURPOSE_FAIL; + return ret; } - if ((purposeParam->uint32Param & HKS_KEY_PURPOSE_VERIFY) == 0) { - HKS_LOG_E("invalid purpose: 0x%x", purposeParam->uint32Param); - return HKS_ERROR_INVALID_PURPOSE; + + if (algParam->uint32Param == HKS_ALG_ED25519) { + if (key->size != (HKS_CURVE25519_KEY_SIZE_256 / HKS_BITS_PER_BYTE)) { + HKS_LOG_E("invalid key size: %u", key->size); + return HKS_ERROR_INVALID_KEY_SIZE; + } + + if (signature->size < HKS_SIGNATURE_MIN_SIZE) { + HKS_LOG_E("signature size too small, size: %u", signature->size); + return HKS_ERROR_INVALID_SIGNATURE_SIZE; + } } return HKS_SUCCESS; } -int32_t HksLocalVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, - const struct HksBlob *srcData, const struct HksBlob *signature) +int32_t HksLocalSign(const struct HksBlob *key, const struct HksParamSet *paramSet, const struct HksBlob *srcData, + struct HksBlob *signature) +{ + int32_t ret = CheckLocalSignVerifyParams(HKS_CMD_ID_SIGN, key, paramSet, srcData, signature); + if (ret != HKS_SUCCESS) { + return ret; + } + + struct HksUsageSpec usageSpec = {0}; + HksFillUsageSpec(paramSet, &usageSpec); + + struct HksBlob keyMaterial = { 0, NULL }; + ret = HksSetKeyToMaterial(usageSpec.algType, false, key, &keyMaterial); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("set key to material failed, ret:%x!", ret); + return ret; + } + + ret = HksCryptoHalSign(&keyMaterial, &usageSpec, srcData, signature); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("local engine verify failed, ret:%x!", ret); + } + + (void)memset_s(keyMaterial.data, keyMaterial.size, 0, keyMaterial.size); + HKS_FREE_PTR(keyMaterial.data); + return ret; +} + +int32_t HksLocalVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, const struct HksBlob *srcData, + const struct HksBlob *signature) { - int32_t ret = CheckLocalVerifyParams(key, paramSet, srcData, signature); + int32_t ret = CheckLocalSignVerifyParams(HKS_CMD_ID_VERIFY, key, paramSet, srcData, signature); if (ret != HKS_SUCCESS) { return ret; } @@ -330,7 +372,6 @@ int32_t HksLocalVerify(const struct HksBlob *key, const struct HksParamSet *para return ret; } - /* Only ed25519 is allowed here */ ret = HksCryptoHalVerify(&keyMaterial, &usageSpec, srcData, signature); if (ret != HKS_SUCCESS) { HKS_LOG_E("local engine verify failed, ret:%x!", ret); diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/BUILD.gn b/frameworks/huks_standard/main/crypto_engine/mbedtls/BUILD.gn index bccf5fec..4491f07f 100755 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/BUILD.gn +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/BUILD.gn @@ -39,6 +39,7 @@ ohos_static_library("libhuks_mbedtls_standard_static") { "src/hks_mbedtls_aes.c", "src/hks_mbedtls_bn.c", "src/hks_mbedtls_common.c", + "src/hks_mbedtls_dh.c", "src/hks_mbedtls_dsa.c", "src/hks_mbedtls_ecc.c", "src/hks_mbedtls_ecdh.c", diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_aes.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_aes.h index 91fc1239..2d9b43f7 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_aes.h +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_aes.h @@ -29,15 +29,17 @@ extern "C" { #endif +#ifdef HKS_SUPPORT_AES_C #ifdef HKS_SUPPORT_AES_GENERATE_KEY int32_t HksMbedtlsAesGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); -#endif +#endif /* HKS_SUPPORT_AES_GENERATE_KEY */ int32_t HksMbedtlsAesEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead); int32_t HksMbedtlsAesDecrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText); +#endif /* HKS_SUPPORT_AES_C */ #ifdef __cplusplus } diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dh.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dh.h new file mode 100755 index 00000000..d7a7f366 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dh.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HKS_MBEDTLS_DH_H +#define HKS_MBEDTLS_DH_H + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#include "hks_crypto_hal.h" +#include "hks_type_inner.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef HKS_SUPPORT_DH_C +#ifdef HKS_SUPPORT_DH_GENERATE_KEY +int32_t HksMbedtlsDhGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_DH_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_DH_GET_PUBLIC_KEY +int32_t HksMbedtlsGetDhPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_DH_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DH_AGREE_KEY +int32_t HksMbedtlsDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, + const struct HksKeySpec *spec, struct HksBlob *sharedKey); +#endif /* HKS_SUPPORT_DH_AGREE_KEY */ +#endif /* HKS_SUPPORT_DH_C */ + +#ifdef __cplusplus +} +#endif + +#endif /* HKS_MBEDTLS_DH_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dsa.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dsa.h index 1cba8dc1..a08eaffb 100755 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dsa.h +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_dsa.h @@ -29,8 +29,23 @@ extern "C" { #endif +#ifdef HKS_SUPPORT_DSA_C +#ifdef HKS_SUPPORT_DSA_GENERATE_KEY int32_t HksMbedtlsDsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_DSA_GENERATE_KEY */ +#ifdef HKS_SUPPORT_DSA_GET_PUBLIC_KEY +int32_t HksMbedtlsGetDsaPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_DSA_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DSA_SIGN_VERIFY +int32_t HksMbedtlsDsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature); + +int32_t HksMbedtlsDsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature); +#endif /* HKS_SUPPORT_DSA_SIGN_VERIFY */ +#endif /* HKS_SUPPORT_DSA_C */ #ifdef __cplusplus } diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_ecdsa.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_ecdsa.h index 055f3437..d8f42e3c 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_ecdsa.h +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_ecdsa.h @@ -29,11 +29,8 @@ extern "C" { #endif -int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, - const struct HksBlob *message, struct HksBlob *signature); - -int32_t HksMbedtlsEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, - const struct HksBlob *message, const struct HksBlob *signature); +int32_t HksMbedtlsEcdsaSignVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature, bool isVerify); #ifdef __cplusplus } diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_hmac.h b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_hmac.h index 4abe2f49..1b48eeaf 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_hmac.h +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/include/hks_mbedtls_hmac.h @@ -29,7 +29,9 @@ extern "C" { #endif +#ifdef HKS_SUPPORT_HMAC_GENERATE_KEY int32_t HksMbedtlsHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif int32_t HksMbedtlsHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac); diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_aes.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_aes.c index 79bef376..be85a3a8 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_aes.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_aes.c @@ -344,6 +344,7 @@ static int32_t AesDecryptCcm(const struct HksBlob *key, const struct HksUsageSpe } #endif /* HKS_SUPPORT_AES_CCM */ +#ifdef HKS_SUPPORT_AES_CTR_NOPADDING static int32_t AesCtrCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText) { @@ -378,12 +379,16 @@ static int32_t AesCtrCrypt(const struct HksBlob *key, const struct HksUsageSpec } cipherText->size = olen; + mbedtls_cipher_free(&ctx); return HKS_SUCCESS; } while (0); + mbedtls_cipher_free(&ctx); return HKS_ERROR_CRYPTO_ENGINE_ERROR; } +#endif +#ifdef HKS_SUPPORT_AES_ECB_NOPADDING static int32_t AesEcbNoPaddingCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText) { @@ -416,18 +421,23 @@ static int32_t AesEcbNoPaddingCrypt(const struct HksBlob *key, const struct HksU } cipherText->size = olen; + mbedtls_cipher_free(&ctx); return HKS_SUCCESS; } while (0); + mbedtls_cipher_free(&ctx); return HKS_ERROR_CRYPTO_ENGINE_ERROR; } +#endif static int32_t AesEcbCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText) { switch (usageSpec->padding) { +#ifdef HKS_SUPPORT_AES_ECB_NOPADDING case HKS_PADDING_NONE: return AesEcbNoPaddingCrypt(key, usageSpec, message, encrypt, cipherText); +#endif case HKS_PADDING_PKCS7: return HKS_ERROR_NOT_SUPPORTED; default: @@ -467,10 +477,14 @@ int32_t HksMbedtlsAesEncrypt(const struct HksBlob *key, const struct HksUsageSpe case HKS_MODE_CCM: return AesEncryptCcm(key, usageSpec, message, cipherText, tagAead); #endif +#ifdef HKS_SUPPORT_AES_CTR_NOPADDING case HKS_MODE_CTR: return AesCtrCrypt(key, usageSpec, message, true, cipherText); +#endif +#if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING) case HKS_MODE_ECB: return AesEcbCrypt(key, usageSpec, message, true, cipherText); +#endif default: HKS_LOG_E("Unsupport key alg! mode = 0x%X", usageSpec->mode); return HKS_ERROR_INVALID_ARGUMENT; @@ -498,10 +512,14 @@ int32_t HksMbedtlsAesDecrypt(const struct HksBlob *key, const struct HksUsageSpe case HKS_MODE_CCM: return AesDecryptCcm(key, usageSpec, message, cipherText); #endif +#ifdef HKS_SUPPORT_AES_CTR_NOPADDING case HKS_MODE_CTR: return AesCtrCrypt(key, usageSpec, message, false, cipherText); +#endif +#if defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING) case HKS_MODE_ECB: return AesEcbCrypt(key, usageSpec, message, false, cipherText); +#endif default: HKS_LOG_E("Unsupport key alg! mode = 0x%X", usageSpec->mode); return HKS_ERROR_INVALID_ARGUMENT; diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_common.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_common.c index 9b90f046..26a019df 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_common.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_common.c @@ -35,6 +35,9 @@ const unsigned char g_hksRandomSeedCustom[] = { int32_t HksToMbedtlsDigestAlg(const uint32_t hksAlg, uint32_t *mbedtlsAlg) { switch (hksAlg) { + case HKS_DIGEST_MD5: + *mbedtlsAlg = MBEDTLS_MD_MD5; + break; case HKS_DIGEST_SHA1: *mbedtlsAlg = MBEDTLS_MD_SHA1; break; diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dh.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dh.c new file mode 100755 index 00000000..b6d941da --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_dh.c @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_DH_C + +#include "hks_mbedtls_dh.h" + +#include + +#include "hks_log.h" +#include "hks_mbedtls_common.h" +#include "hks_mem.h" + +#define HKS_Dh_KEYPAIR_CNT 2 + +#if defined(HKS_SUPPORT_DH_GENERATE_KEY) || defined(HKS_SUPPORT_DH_AGREE_KEY) +static uint8_t ffdhe2048ParamG[] = MBEDTLS_DHM_RFC7919_FFDHE2048_G_BIN; +static uint8_t ffdhe2048ParamP[] = MBEDTLS_DHM_RFC7919_FFDHE2048_P_BIN; +static uint8_t ffdhe3072ParamG[] = MBEDTLS_DHM_RFC7919_FFDHE3072_G_BIN; +static uint8_t ffdhe3072ParamP[] = MBEDTLS_DHM_RFC7919_FFDHE3072_P_BIN; +static uint8_t ffdhe4096ParamG[] = MBEDTLS_DHM_RFC7919_FFDHE4096_G_BIN; +static uint8_t ffdhe4096ParamP[] = MBEDTLS_DHM_RFC7919_FFDHE4096_P_BIN; + +static int32_t GetDhParam(uint32_t keySize, struct HksBlob *P, struct HksBlob *G) +{ + switch (keySize) { + case HKS_DH_KEY_SIZE_2048: + P->data = ffdhe2048ParamP; + P->size = sizeof(ffdhe2048ParamP); + G->data = ffdhe2048ParamG; + G->size = sizeof(ffdhe2048ParamG); + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_3072: + P->data = ffdhe3072ParamP; + P->size = sizeof(ffdhe3072ParamP); + G->data = ffdhe3072ParamG; + G->size = sizeof(ffdhe3072ParamG); + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_4096: + P->data = ffdhe4096ParamP; + P->size = sizeof(ffdhe4096ParamP); + G->data = ffdhe4096ParamG; + G->size = sizeof(ffdhe4096ParamG); + return HKS_SUCCESS; + default: + return HKS_ERROR_INVALID_KEY_SIZE; + } +} +#endif + +#ifdef HKS_SUPPORT_DH_GENERATE_KEY +static int32_t DhSaveKeyMaterial(const mbedtls_dhm_context *ctx, const uint32_t keySize, struct HksBlob *key) +{ + const uint32_t keyByteLen = HKS_KEY_BYTES(keySize); + const uint32_t rawMaterialLen = sizeof(struct KeyMaterialDh) + keyByteLen * HKS_Dh_KEYPAIR_CNT; + uint8_t *rawMaterial = (uint8_t *)HksMalloc(rawMaterialLen); + if (rawMaterial == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + (void)memset_s(rawMaterial, rawMaterialLen, 0, rawMaterialLen); + + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = keySize; + keyMaterial->pubKeySize = mbedtls_mpi_size(&ctx->GX); + keyMaterial->priKeySize = mbedtls_mpi_size(&ctx->X); + + int32_t ret; + do { + uint32_t offset = sizeof(*keyMaterial); + ret = mbedtls_mpi_write_binary(&(ctx->GX), rawMaterial + offset, keyMaterial->pubKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("mbedtls_mpi_write_binary failed! mbedtls ret = 0x%X", ret); + break; + } + + offset = offset + keyMaterial->pubKeySize; + ret = mbedtls_mpi_write_binary(&(ctx->X), rawMaterial + offset, keyMaterial->priKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("mbedtls_mpi_write_binary failed! mbedtls ret = 0x%X", ret); + break; + } + + key->data = rawMaterial; + key->size = rawMaterialLen; + } while (0); + + return HKS_SUCCESS; +} + +int32_t HksMbedtlsDhGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + mbedtls_dhm_context ctx; + mbedtls_dhm_init(&ctx); + + mbedtls_entropy_context entropy; + mbedtls_ctr_drbg_context ctrDrbg; + int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy); + if (ret != HKS_SUCCESS) { + mbedtls_dhm_free(&ctx); + return ret; + } + + do { + struct HksBlob paramP; + struct HksBlob paramG; + ret = GetDhParam(spec->keyLen, ¶mP, ¶mG); + if (ret != HKS_SUCCESS) { + break; + } + uint32_t keyLen = HKS_KEY_BYTES(spec->keyLen); + + if (mbedtls_mpi_read_binary(&ctx.P, paramP.data, paramP.size) != HKS_MBEDTLS_SUCCESS || + mbedtls_mpi_read_binary(&ctx.G, paramG.data, paramG.size) != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + ctx.len = keyLen; + + uint8_t *output = HksMalloc(keyLen); + ret = mbedtls_dhm_make_public(&ctx, keyLen, output, keyLen, mbedtls_ctr_drbg_random, &ctrDrbg); + if (ret != HKS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + } else { + ret = DhSaveKeyMaterial(&ctx, spec->keyLen, key); + } + HksFree(output); + } while (0); + + mbedtls_dhm_free(&ctx); + mbedtls_ctr_drbg_free(&ctrDrbg); + mbedtls_entropy_free(&entropy); + + return ret; +} +#endif + +#ifdef HKS_SUPPORT_DH_GET_PUBLIC_KEY +int32_t HksMbedtlsGetDhPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)input->data; + if (input->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return HKS_ERROR_INVALID_ARGUMENT; + } + if (output->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + (void)memcpy_s(output->data, output->size, input->data, sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize); + ((struct KeyMaterialDh *)output->data)->priKeySize = 0; + ((struct KeyMaterialDh *)output->data)->reserved = 0; + output->size = sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize; + + return HKS_SUCCESS; +} +#endif + +#ifdef HKS_SUPPORT_DH_AGREE_KEY +static int32_t DhKeyMaterialToCtx(const struct HksBlob *key, const bool needPrivateExponent, mbedtls_dhm_context *ctx) +{ + const struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)(key->data); + + int32_t ret; + do { + struct HksBlob paramP; + struct HksBlob paramG; + ret = GetDhParam(keyMaterial->keySize, ¶mP, ¶mG); + if (ret != HKS_SUCCESS) { + break; + } + + if (mbedtls_mpi_read_binary(&ctx->P, paramP.data, paramP.size) != HKS_MBEDTLS_SUCCESS || + mbedtls_mpi_read_binary(&ctx->G, paramG.data, paramG.size) != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + ctx->len = HKS_KEY_BYTES(keyMaterial->keySize); + + uint32_t offset = sizeof(struct KeyMaterialDh); + ret = mbedtls_mpi_read_binary(&ctx->GX, key->data + offset, keyMaterial->pubKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + HKS_LOG_E("mbedtls_mpi_read_binary failed! mbedtls ret = 0x%X", ret); + break; + } + + if (needPrivateExponent) { + offset = offset + keyMaterial->pubKeySize; + ret = mbedtls_mpi_read_binary(&ctx->X, key->data + offset, keyMaterial->priKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + HKS_LOG_E("mbedtls_mpi_read_binary failed! mbedtls ret = 0x%X", ret); + break; + } + } + + ret = HKS_SUCCESS; + } while (0); + + return ret; +} + +int32_t HksMbedtlsDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, + const struct HksKeySpec *spec, struct HksBlob *sharedKey) +{ + if (HKS_KEY_BYTES(spec->keyLen) > sharedKey->size) { + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data; + + mbedtls_dhm_context ctx; + mbedtls_dhm_init(&ctx); + + mbedtls_entropy_context entropy; + mbedtls_ctr_drbg_context ctrDrbg; + int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy); + if (ret != HKS_SUCCESS) { + mbedtls_dhm_free(&ctx); + return ret; + } + + do { + ret = DhKeyMaterialToCtx(nativeKey, true, &ctx); + if (ret != HKS_SUCCESS) { + break; + } + + ret = mbedtls_dhm_read_public(&ctx, pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("mbedtls_dhm_read_public failed! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + + size_t keyLen; + ret = + mbedtls_dhm_calc_secret(&ctx, sharedKey->data, sharedKey->size, &keyLen, mbedtls_ctr_drbg_random, &ctrDrbg); + if (ret != HKS_MBEDTLS_SUCCESS) { + HKS_LOG_E("mbedtls_dhm_calc_secret failed! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + break; + } + sharedKey->size = keyLen; + ret = HKS_SUCCESS; + } while (0); + + mbedtls_dhm_free(&ctx); + mbedtls_ctr_drbg_free(&ctrDrbg); + mbedtls_entropy_free(&entropy); + + return ret; +} +#endif + +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecc.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecc.c index 5360c046..58cd5639 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecc.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecc.c @@ -40,7 +40,8 @@ static int32_t HksMbedtlsEccCheckKeySize(const uint32_t keySize) { - if ((keySize != HKS_ECC_KEY_SIZE_256) && (keySize != HKS_ECC_KEY_SIZE_384)) { + if ((keySize != HKS_ECC_KEY_SIZE_224) && (keySize != HKS_ECC_KEY_SIZE_256) && (keySize != HKS_ECC_KEY_SIZE_384) && + (keySize != HKS_ECC_KEY_SIZE_521)) { HKS_LOG_E("Invalid ecc keySize! keySize = 0x%X", keySize); return HKS_ERROR_INVALID_KEY_SIZE; } @@ -72,7 +73,7 @@ int32_t GetEccGroupId(const uint32_t keyLen, mbedtls_ecp_group_id *grpId) static int32_t EccKeyMaterialXyzSizeCheck(const struct KeyMaterialEcc *keyMaterial) { - const uint32_t maxKeyByteLen = HKS_ECC_KEY_SIZE_384 / HKS_BITS_PER_BYTE; + const uint32_t maxKeyByteLen = HKS_KEY_BYTES(HKS_ECC_KEY_SIZE_521); if ((keyMaterial->xSize > maxKeyByteLen) || (keyMaterial->ySize > maxKeyByteLen) || (keyMaterial->zSize > maxKeyByteLen)) { HKS_LOG_E("Invalid ecc keyMaterial! xSize = 0x%X, ySize = 0x%X, zSize = 0x%X", diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdh.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdh.c index 30552c32..0ecf04ef 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdh.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdh.c @@ -37,6 +37,7 @@ #include "hks_mbedtls_common.h" #include "hks_mbedtls_ecc.h" +#ifdef HKS_SUPPORT_ECDH_AGREE_KEY static int32_t EccKeyMaterialToCtx(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, mbedtls_ecdh_context *ctx) { @@ -96,7 +97,7 @@ int32_t HksMbedtlsEcdh(const struct HksBlob *nativeKey, break; } - const uint32_t keyByteLen = spec->keyLen / HKS_BITS_PER_BYTE; + const uint32_t keyByteLen = HKS_KEY_BYTES(spec->keyLen); ret = mbedtls_mpi_write_binary(&(ctx.z), sharedKey->data, keyByteLen); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls ecdh mpi write to sharedKey failed! mbedtls ret = 0x%X", ret); @@ -111,4 +112,5 @@ int32_t HksMbedtlsEcdh(const struct HksBlob *nativeKey, mbedtls_entropy_free(&entropy); return ret; } +#endif /* HKS_SUPPORT_ECDH_AGREE_KEY */ #endif /* HKS_SUPPORT_ECDH_C */ diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdsa.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdsa.c index 9ca5c449..5bd9d04d 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdsa.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_ecdsa.c @@ -32,12 +32,16 @@ #include #include +#include "hks_common_check.h" #include "hks_log.h" +#include "hks_mem.h" #include "hks_mbedtls_common.h" #include "hks_mbedtls_ecc.h" +#include "hks_mbedtls_hash.h" +#ifdef HKS_SUPPORT_ECDSA_SIGN_VERIFY /* users must ensure the input params not null */ -int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, +static int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature) { int32_t ret = EccKeyCheck(key); @@ -74,7 +78,8 @@ int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec } uint32_t mbedtlsAlg; - ret = HksToMbedtlsDigestAlg(usageSpec->digest, &mbedtlsAlg); + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + ret = HksToMbedtlsDigestAlg(digest, &mbedtlsAlg); if (ret != HKS_SUCCESS) { break; } @@ -84,6 +89,7 @@ int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Ecc mbedtls sign fail! mbedtls ret = 0x%X", ret); (void)memset_s(signature->data, signature->size, 0, signature->size); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; } } while (0); @@ -94,7 +100,7 @@ int32_t HksMbedtlsEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec } /* users must ensure the input params not null */ -int32_t HksMbedtlsEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, +static int32_t HksMbedtlsEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const struct HksBlob *signature) { (void)usageSpec; @@ -129,10 +135,42 @@ int32_t HksMbedtlsEcdsaVerify(const struct HksBlob *key, const struct HksUsageSp message->data, message->size, signature->data, signature->size); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Ecc mbedtls verify fail! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; } - }while (0); + } while (0); mbedtls_ecdsa_free(&ctx); return ret; } + +int32_t HksMbedtlsEcdsaSignVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature, bool isVerify) +{ + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + uint32_t digestLen; + int32_t ret = HksGetDigestLen(digest, &digestLen); + if (ret != HKS_SUCCESS) { + return ret; + } + struct HksBlob hash = { .size = digestLen, .data = HksMalloc(digestLen) }; + if (hash.data == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + ret = HksMbedtlsHash(digest, message, &hash); + if (ret != HKS_SUCCESS) { + HKS_FREE_BLOB(hash); + return ret; + } + + if (isVerify) { + ret = HksMbedtlsEcdsaVerify(key, usageSpec, &hash, signature); + } else { + ret = HksMbedtlsEcdsaSign(key, usageSpec, &hash, (struct HksBlob *)signature); + } + HKS_FREE_BLOB(hash); + + return ret; +} +#endif /* HKS_SUPPORT_ECDSA_SIGN_VERIFY */ #endif /* HKS_SUPPORT_ECDSA_C */ diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c index 14c5c13f..6bb1f1f5 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c @@ -31,6 +31,7 @@ #include "hks_mbedtls_aes.h" #include "hks_mbedtls_bn.h" #include "hks_mbedtls_common.h" +#include "hks_mbedtls_dh.h" #include "hks_mbedtls_dsa.h" #include "hks_mbedtls_ecc.h" #include "hks_mbedtls_ecdh.h" @@ -54,26 +55,18 @@ #undef HKS_SUPPORT_KDF_PBKDF2 #endif -static inline int32_t HksMbedtlsCheckBlob(const struct HksBlob *blob) -{ - if ((blob == NULL) || (blob->data == NULL) || (blob->size == 0)) { - return HKS_ERROR_INVALID_ARGUMENT; - } - return HKS_SUCCESS; -} - static int32_t EncryptCheckParam(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText) { - if (HksMbedtlsCheckBlob(key) != HKS_SUCCESS) { + if (CheckBlob(key) != HKS_SUCCESS) { HKS_LOG_E("Invalid param key!"); return HKS_ERROR_INVALID_ARGUMENT; } - if (HksMbedtlsCheckBlob(message) != HKS_SUCCESS) { + if (CheckBlob(message) != HKS_SUCCESS) { HKS_LOG_E("Invalid param message!"); return HKS_ERROR_INVALID_ARGUMENT; } - if (HksMbedtlsCheckBlob(cipherText) != HKS_SUCCESS) { + if (CheckBlob(cipherText) != HKS_SUCCESS) { HKS_LOG_E("Invalid param cipherText!"); return HKS_ERROR_INVALID_ARGUMENT; } @@ -136,6 +129,7 @@ int32_t HksCryptoHalGenerateKey(const struct HksKeySpec *spec, struct HksBlob *k #endif #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) case HKS_ALG_ECC: + case HKS_ALG_ECDH: return HksMbedtlsEccGenerateKey(spec, key); #endif #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_GENERATE_KEY) @@ -153,6 +147,10 @@ int32_t HksCryptoHalGenerateKey(const struct HksKeySpec *spec, struct HksBlob *k #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) case HKS_ALG_DSA: return HksMbedtlsDsaGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY) + case HKS_ALG_DH: + return HksMbedtlsDhGenerateKey(spec, key); #endif default: HKS_LOG_E("Unsupport alg type or macro is not on! type = 0x%X", spec->algType); @@ -210,6 +208,10 @@ int32_t HksCryptoHalGetPubKey(const struct HksBlob *keyIn, struct HksBlob *keyOu #if defined(HKS_SUPPORT_X25519_C) && defined(HKS_SUPPORT_X25519_GET_PUBLIC_KEY) case HKS_ALG_X25519: return HksMbedtlsGetX25519PubKey(keyIn, keyOut); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY) + case HKS_ALG_DH: + return HksMbedtlsGetDhPubKey(keyIn, keyOut); #endif default: HKS_LOG_E("Unsupport key mode or macro is not on! mode = 0x%X", key->keyAlg); @@ -234,7 +236,7 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl const struct HksKeySpec *spec, struct HksBlob *sharedKey) { switch (spec->algType) { -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) && defined(HKS_SUPPORT_ECDH_AGREE_KEY) case HKS_ALG_ECDH: return HksMbedtlsEcdh(nativeKey, pubKey, spec, sharedKey); #endif @@ -245,6 +247,10 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl #ifdef HKS_SUPPORT_ED25519_TO_X25519 case HKS_ALG_ED25519: return HksMbedtlsEd25519KeyAgreement(nativeKey, pubKey, sharedKey); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_AGREE_KEY) + case HKS_ALG_DH: + return HksMbedtlsDhAgreeKey(nativeKey, pubKey, spec, sharedKey); #endif default: HKS_LOG_E("Unsupport alg or macro is not on! alg = 0x%X", spec->algType); @@ -260,9 +266,9 @@ int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *u case HKS_ALG_RSA: return HksMbedtlsRsaSign(key, usageSpec, message, signature); #endif -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) case HKS_ALG_ECC: - return HksMbedtlsEcdsaSign(key, usageSpec, message, signature); + return HksMbedtlsEcdsaSignVerify(key, usageSpec, message, signature, false); #endif #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) case HKS_ALG_ED25519: @@ -282,9 +288,9 @@ int32_t HksCryptoHalVerify(const struct HksBlob *key, const struct HksUsageSpec case HKS_ALG_RSA: return HksMbedtlsRsaVerify(key, usageSpec, message, signature); #endif -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) case HKS_ALG_ECC: - return HksMbedtlsEcdsaVerify(key, usageSpec, message, signature); + return HksMbedtlsEcdsaSignVerify(key, usageSpec, message, signature, true); #endif #if defined(HKS_SUPPORT_ED25519_C) && defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) case HKS_ALG_ED25519: diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hash.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hash.c index 7678da9c..909d95d6 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hash.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hash.c @@ -27,6 +27,8 @@ #include "hks_mbedtls_hash.h" +#include +#include #include #include @@ -38,6 +40,15 @@ int32_t HksMbedtlsHash(uint32_t alg, const struct HksBlob *msg, struct HksBlob * { int32_t ret; switch (alg) { + case HKS_DIGEST_MD5: + ret = mbedtls_md5_ret(msg->data, msg->size, hash->data); /* 0 for MD5 */ + break; + case HKS_DIGEST_SHA1: + ret = mbedtls_sha1_ret(msg->data, msg->size, hash->data); /* 0 for SHA-1 */ + break; + case HKS_DIGEST_SHA224: + ret = mbedtls_sha256_ret(msg->data, msg->size, hash->data, 1); /* 0 for SHA-224 */ + break; case HKS_DIGEST_SHA256: ret = mbedtls_sha256_ret(msg->data, msg->size, hash->data, 0); /* 0 for SHA-256 */ break; diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hmac.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hmac.c index ba00452d..5f8f26eb 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hmac.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_hmac.c @@ -30,6 +30,7 @@ #include "hks_mbedtls_common.h" #include "hks_mem.h" +#ifdef HKS_SUPPORT_HMAC_GENERATE_KEY int32_t HksMbedtlsHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) { if (spec->keyLen % HKS_BITS_PER_BYTE != 0) { @@ -68,6 +69,7 @@ int32_t HksMbedtlsHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob mbedtls_entropy_free(&entropy); return ret; } +#endif /* HKS_SUPPORT_HMAC_GENERATE_KEY */ int32_t HksMbedtlsHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c index 1ef4174e..50847205 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c @@ -32,8 +32,10 @@ #include #include +#include "hks_common_check.h" #include "hks_log.h" #include "hks_mbedtls_common.h" +#include "hks_mbedtls_hash.h" #include "hks_mem.h" #define HKS_RSA_PUBLIC_EXPONENT 65537 @@ -143,6 +145,7 @@ static int32_t RsaSaveKeyMaterial(const mbedtls_rsa_context *ctx, const uint32_t if (ret != HKS_MBEDTLS_SUCCESS) { (void)memset_s(rawMaterial, rawMaterialLen, 0, rawMaterialLen); HKS_FREE_PTR(rawMaterial); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; } return ret; @@ -159,6 +162,7 @@ int32_t HksMbedtlsRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob * mbedtls_entropy_context entropy; int32_t ret = HksCtrDrbgSeed(&ctrDrbg, &entropy); if (ret != HKS_SUCCESS) { + mbedtls_rsa_free(&ctx); return ret; } @@ -166,6 +170,7 @@ int32_t HksMbedtlsRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob * ret = mbedtls_rsa_gen_key(&ctx, mbedtls_ctr_drbg_random, &ctrDrbg, spec->keyLen, HKS_RSA_PUBLIC_EXPONENT); if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls rsa generate key failed! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; break; } @@ -232,6 +237,10 @@ static int32_t RsaKeyMaterialToCtx(const struct HksBlob *key, const bool needPri mbedtls_mpi_free(&n); mbedtls_mpi_free(&e); mbedtls_mpi_free(&d); + + if (ret != HKS_MBEDTLS_SUCCESS) { + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; + } return ret; } #endif /* HKS_SUPPORT_RSA_CRYPT or HKS_SUPPORT_RSA_SIGN_VERIFY */ @@ -302,6 +311,7 @@ int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec if (ret != HKS_SUCCESS) { HKS_LOG_E("Mbedtls rsa crypt failed! mbedtls ret = 0x%X", ret); (void)memset_s(cipherText->data, cipherText->size, 0, cipherText->size); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; break; } cipherText->size = (uint32_t)outlen; @@ -315,11 +325,31 @@ int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec #endif /* HKS_SUPPORT_RSA_CRYPT */ #ifdef HKS_SUPPORT_RSA_SIGN_VERIFY +int32_t HksToMbedtlsSignPadding(uint32_t hksPadding, int32_t *padding) +{ + switch (hksPadding) { + case HKS_PADDING_PKCS1_V1_5: + *padding = MBEDTLS_RSA_PKCS_V15; + break; + case HKS_PADDING_PSS: + *padding = MBEDTLS_RSA_PKCS_V21; + break; + default: + return HKS_ERROR_NOT_SUPPORTED; + } + return HKS_SUCCESS; +} static int32_t HksMbedtlsRsaSignVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const bool sign, struct HksBlob *signature) { uint32_t mbedtlsAlg; - int32_t ret = HksToMbedtlsDigestAlg(usageSpec->digest, &mbedtlsAlg); + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + int32_t ret = HksToMbedtlsDigestAlg(digest, &mbedtlsAlg); + if (ret != HKS_SUCCESS) { + return ret; + } + int32_t padding; + ret = HksToMbedtlsSignPadding(usageSpec->padding, &padding); if (ret != HKS_SUCCESS) { return ret; } @@ -332,7 +362,7 @@ static int32_t HksMbedtlsRsaSignVerify(const struct HksBlob *key, const struct H } mbedtls_rsa_context ctx; - mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V21, mbedtlsAlg); /* only support pss padding */ + mbedtls_rsa_init(&ctx, padding, mbedtlsAlg); do { ret = RsaKeyMaterialToCtx(key, sign, &ctx); /* sign need private exponent (d) */ @@ -341,26 +371,15 @@ static int32_t HksMbedtlsRsaSignVerify(const struct HksBlob *key, const struct H } if (sign) { - ret = mbedtls_rsa_pkcs1_sign(&ctx, - mbedtls_ctr_drbg_random, - &ctrDrbg, - MBEDTLS_RSA_PRIVATE, - mbedtlsAlg, - message->size, - message->data, - signature->data); + ret = mbedtls_rsa_pkcs1_sign(&ctx, mbedtls_ctr_drbg_random, &ctrDrbg, MBEDTLS_RSA_PRIVATE, + mbedtlsAlg, message->size, message->data, signature->data); } else { - ret = mbedtls_rsa_pkcs1_verify(&ctx, - mbedtls_ctr_drbg_random, - &ctrDrbg, - MBEDTLS_RSA_PUBLIC, - mbedtlsAlg, - message->size, - message->data, - signature->data); + ret = mbedtls_rsa_pkcs1_verify(&ctx, mbedtls_ctr_drbg_random, &ctrDrbg, MBEDTLS_RSA_PUBLIC, + mbedtlsAlg, message->size, message->data, signature->data); } - if (ret != HKS_SUCCESS) { + if (ret != HKS_MBEDTLS_SUCCESS) { HKS_LOG_E("Mbedtls rsa sign/verify failed! mbedtls ret = 0x%X", ret); + ret = HKS_ERROR_CRYPTO_ENGINE_ERROR; (void)memset_s(signature->data, signature->size, 0, signature->size); } } while (0); @@ -383,7 +402,26 @@ int32_t HksMbedtlsRsaSign(const struct HksBlob *key, const struct HksUsageSpec * return ret; } - return HksMbedtlsRsaSignVerify(key, usageSpec, message, true, signature); /* true: is sign */ + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + uint32_t digestLen; + ret = HksGetDigestLen(digest, &digestLen); + if (ret != HKS_SUCCESS) { + return ret; + } + struct HksBlob hash = { .size = digestLen, .data = HksMalloc(digestLen) }; + if (hash.data == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + ret = HksMbedtlsHash(digest, message, &hash); + if (ret != HKS_SUCCESS) { + HKS_FREE_BLOB(hash); + return ret; + } + + ret = HksMbedtlsRsaSignVerify(key, usageSpec, &hash, true, signature); /* true: is sign */ + HKS_FREE_BLOB(hash); + return ret; } int32_t HksMbedtlsRsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, @@ -394,7 +432,26 @@ int32_t HksMbedtlsRsaVerify(const struct HksBlob *key, const struct HksUsageSpec return ret; } - return HksMbedtlsRsaSignVerify(key, usageSpec, message, false, (struct HksBlob *)signature); /* false: is verify */ + uint32_t digest = (usageSpec->digest == HKS_DIGEST_NONE) ? HKS_DIGEST_SHA256 : usageSpec->digest; + uint32_t digestLen; + ret = HksGetDigestLen(digest, &digestLen); + if (ret != HKS_SUCCESS) { + return ret; + } + struct HksBlob hash = { .size = digestLen, .data = HksMalloc(digestLen) }; + if (hash.data == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + ret = HksMbedtlsHash(digest, message, &hash); + if (ret != HKS_SUCCESS) { + HKS_FREE_BLOB(hash); + return ret; + } + + ret = HksMbedtlsRsaSignVerify(key, usageSpec, &hash, false, (struct HksBlob *)signature); /* false: is verify */ + HKS_FREE_BLOB(hash); + return ret; } #endif /* HKS_SUPPORT_RSA_SIGN_VERIFY */ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/BUILD.gn b/frameworks/huks_standard/main/crypto_engine/openssl/BUILD.gn index 28b91fd5..1b516604 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/BUILD.gn +++ b/frameworks/huks_standard/main/crypto_engine/openssl/BUILD.gn @@ -35,6 +35,7 @@ ohos_static_library("libhuks_openssl_standard_static") { sources = [ "src/hks_openssl_aes.c", "src/hks_openssl_curve25519.c", + "src/hks_openssl_dh.c", "src/hks_openssl_dsa.c", "src/hks_openssl_ecc.c", "src/hks_openssl_ed25519tox25519.c", diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_aes.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_aes.h index e0f6f629..aeffc098 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_aes.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_aes.h @@ -22,15 +22,21 @@ extern "C" { #endif +#ifdef HKS_SUPPORT_AES_C #ifdef HKS_SUPPORT_AES_GENERATE_KEY int32_t HksOpensslAesGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); -#endif +#endif /* HKS_SUPPORT_AES_GENERATE_KEY */ +#if defined(HKS_SUPPORT_AES_CBC_NOPADDING) || defined(HKS_SUPPORT_AES_CBC_PKCS7) || \ + defined(HKS_SUPPORT_AES_ECB_PKCS7PADDING) || defined(HKS_SUPPORT_AES_CTR_NOPADDING) || \ + defined(HKS_SUPPORT_AES_ECB_NOPADDING) || defined(HKS_SUPPORT_AES_GCM) int32_t HksOpensslAesEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead); int32_t HksOpensslAesDecrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *cipherText); +#endif /* HKS_SUPPORT_AES_CBC_NOPADDING */ +#endif /* HKS_SUPPORT_AES_C */ #ifdef __cplusplus } diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dh.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dh.h new file mode 100755 index 00000000..7b6b2f3d --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dh.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HKS_OPENSSL_DH_H +#define HKS_OPENSSL_DH_H + +#include "hks_crypto_hal.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef HKS_SUPPORT_DH_C +#ifdef HKS_SUPPORT_DH_GENERATE_KEY +int32_t HksOpensslDhGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_DH_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_DH_GET_PUBLIC_KEY +int32_t HksOpensslGetDhPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_DH_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DH_AGREE_KEY +int32_t HksOpensslDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, + const struct HksKeySpec *spec, struct HksBlob *sharedKey); +#endif /* HKS_SUPPORT_DH_AGREE_KEY */ +#endif /* HKS_SUPPORT_DH_C */ + +#ifdef __cplusplus +} +#endif + +#endif /* HKS_OPENSSL_DH_H */ \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dsa.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dsa.h index b2b27332..11e328f3 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dsa.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_dsa.h @@ -22,14 +22,28 @@ extern "C" { #endif -#define DSA_KEYPAIR_CNT 5 +#define DSA_KEYPAIR_CNT 5 +#ifdef HKS_SUPPORT_DSA_C +#ifdef HKS_SUPPORT_DSA_GENERATE_KEY int32_t HksOpensslDsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_DSA_GENERATE_KEY */ +#ifdef HKS_SUPPORT_DSA_GET_PUBLIC_KEY int32_t HksOpensslGetDsaPubKey(const struct HksBlob *input, struct HksBlob *output); +#endif /* HKS_SUPPORT_DSA_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DSA_SIGN_VERIFY +int32_t HksOpensslDsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature); + +int32_t HksOpensslDsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature); +#endif /* HKS_SUPPORT_DSA_SIGN_VERIFY */ +#endif /* HKS_SUPPORT_DSA_C */ #ifdef __cplusplus } #endif -#endif /* HKS_OPENSSL_DSA_H */ \ No newline at end of file +#endif /* HKS_OPENSSL_DSA_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_ecc.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_ecc.h index 3aebd9fa..b704d94e 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_ecc.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_ecc.h @@ -33,17 +33,21 @@ int32_t HksOpensslEccGenerateKey(const struct HksKeySpec *spec, struct HksBlob * int32_t HksOpensslGetEccPubKey(const struct HksBlob *input, struct HksBlob *output); #endif +#ifdef HKS_SUPPORT_ECDH_AGREE_KEY int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, const struct HksKeySpec *spec, struct HksBlob *sharedKey); +#endif /* HKS_SUPPORT_ECDH_AGREE_KEY */ +#ifdef HKS_SUPPORT_ECDSA_SIGN_VERIFY int32_t HksOpensslEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature); -int32_t HksOpensslEcdsaVerify( - const struct HksBlob *key, const struct HksBlob *message, const struct HksBlob *signature); +int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature); +#endif /* HKS_SUPPORT_ECDSA_SIGN_VERIFY */ #ifdef __cplusplus } #endif -#endif /* HKS_OPENSSL_ECC_H */ \ No newline at end of file +#endif /* HKS_OPENSSL_ECC_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_engine.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_engine.h index 742b097b..a8630c1f 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_engine.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_engine.h @@ -36,7 +36,7 @@ extern "C" { #define HKS_OPENSSL_ERROR_LEN 128 #define BIT_NUM_OF_UINT8 8 -void HksLogOpensslError(); +void HksLogOpensslError(void); int32_t HksOpensslCheckBlob(const struct HksBlob *blob); diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_hmac.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_hmac.h index 94cfa20f..099f0af1 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_hmac.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_hmac.h @@ -22,17 +22,25 @@ extern "C" { #endif +#define HKS_DIGEST_SHA1_LEN 20 +#define HKS_DIGEST_SHA224_LEN 28 #define HKS_DIGEST_SHA256_LEN 32 #define HKS_DIGEST_SHA384_LEN 48 #define HKS_DIGEST_SHA512_LEN 64 +#ifdef HKS_SUPPORT_HMAC_C +#ifdef HKS_SUPPORT_HMAC_GENERATE_KEY int32_t HksOpensslHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); +#endif /* HKS_SUPPORT_HMAC_GENERATE_KEY */ -int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, - struct HksBlob *mac); +#if defined(HKS_SUPPORT_HMAC_SHA1) || defined(HKS_SUPPORT_HMAC_SHA224) || defined(HKS_SUPPORT_HMAC_SHA256) || \ + defined(HKS_SUPPORT_HMAC_SHA384) || defined(HKS_SUPPORT_HMAC_SHA512) +int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac); +#endif /* HKS_SUPPORT_HMAC_SHA1 */ +#endif /* HKS_SUPPORT_HMAC_C */ #ifdef __cplusplus } #endif -#endif /* HKS_OPENSSL_HMAC_H */ \ No newline at end of file +#endif /* HKS_OPENSSL_HMAC_H */ diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_rsa.h b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_rsa.h index b6793e43..1522e6e8 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_rsa.h +++ b/frameworks/huks_standard/main/crypto_engine/openssl/include/hks_openssl_rsa.h @@ -24,18 +24,30 @@ extern "C" { #define HKS_RSA_KEYPAIR_CNT 3 +#ifdef HKS_SUPPORT_RSA_C #ifdef HKS_SUPPORT_RSA_GENERATE_KEY int32_t HksOpensslRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); -#endif +#endif /* HKS_SUPPORT_RSA_GENERATE_KEY */ + #ifdef HKS_SUPPORT_RSA_GET_PUBLIC_KEY int32_t HksOpensslGetRsaPubKey(const struct HksBlob *input, struct HksBlob *output); -#endif +#endif /* HKS_SUPPORT_RSA_GET_PUBLIC_KEY */ + #ifdef HKS_SUPPORT_RSA_CRYPT int32_t HksOpensslRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const bool encrypt, struct HksBlob *cipherText); -#endif +#endif /* HKS_SUPPORT_RSA_CRYPT */ + +#ifdef HKS_SUPPORT_RSA_SIGN_VERIFY +int32_t HksOpensslRsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature); + +int32_t HksOpensslRsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature); +#endif /* HKS_SUPPORT_RSA_SIGN_VERIFY */ +#endif /* HKS_SUPPORT_RSA_C */ #ifdef __cplusplus } #endif -#endif \ No newline at end of file +#endif diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_aes.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_aes.c index bd7cd341..4416e07e 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_aes.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_aes.c @@ -277,6 +277,7 @@ static int32_t OpensslAesCipherInit( const EVP_CIPHER *cipher = GetCipherType(key->size, usageSpec->mode); if (cipher == NULL) { + EVP_CIPHER_CTX_free(*ctx); return HKS_ERROR_INVALID_ARGUMENT; } diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c new file mode 100755 index 00000000..8adc8a06 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_DH_C + +#include "hks_openssl_dh.h" + +#include +#include + +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_openssl_engine.h" +#include "hks_type_inner.h" + +static int32_t HksOpensslGetNid(uint32_t keySize, int *nid) +{ + switch (keySize) { + case HKS_DH_KEY_SIZE_2048: + *nid = NID_ffdhe2048; + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_3072: + *nid = NID_ffdhe3072; + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_4096: + *nid = NID_ffdhe4096; + return HKS_SUCCESS; + default: + HKS_LOG_E("invalid key size, keySize = %d", keySize); + return HKS_ERROR_INVALID_KEY_SIZE; + } +} + +static DH *InitDhStruct(const struct HksBlob *key, const bool needPrivateExponent) +{ + int32_t ret = HKS_SUCCESS; + const struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)(key->data); + if (key->size != sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize + keyMaterial->priKeySize) { + return NULL; + } + + int nid = 0; + ret = HksOpensslGetNid(keyMaterial->keySize, &nid); + if (ret != HKS_SUCCESS) { + return NULL; + } + + DH *dh = DH_new_by_nid(nid); + if (dh == NULL) { + HksLogOpensslError(); + return NULL; + } + + uint32_t offset = sizeof(struct KeyMaterialDh); + BIGNUM *pubKey = BN_bin2bn(key->data + offset, keyMaterial->pubKeySize, NULL); + offset += keyMaterial->pubKeySize; + BIGNUM *privKey = BN_bin2bn(key->data + offset, keyMaterial->priKeySize, NULL); + + if (DH_set0_key(dh, pubKey, privKey) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + DH_free(dh); + return NULL; + } + + return dh; +} + +#ifdef HKS_SUPPORT_DH_GENERATE_KEY +static int32_t DhSaveKeyMaterial(const DH *dh, const uint32_t keySize, struct HksBlob *key) +{ + const BIGNUM *pubKey = NULL; + const BIGNUM *privKey = NULL; + DH_get0_key(dh, &pubKey, &privKey); + const uint32_t rawMaterialLen = sizeof(struct KeyMaterialDh) + BN_num_bytes(pubKey) + BN_num_bytes(privKey); + uint8_t *rawMaterial = (uint8_t *)HksMalloc(rawMaterialLen); + if (rawMaterial == NULL) { + return HKS_ERROR_MALLOC_FAIL; + } + + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = keySize; + keyMaterial->pubKeySize = BN_num_bytes(pubKey); + keyMaterial->priKeySize = BN_num_bytes(privKey); + keyMaterial->reserved = 0; + + uint32_t offset = sizeof(struct KeyMaterialDh); + BN_bn2bin(pubKey, rawMaterial + offset); + offset += keyMaterial->pubKeySize; + BN_bn2bin(privKey, rawMaterial + offset); + offset += keyMaterial->priKeySize; + + key->size = rawMaterialLen; + key->data = rawMaterial; + + return HKS_SUCCESS; +} + +int32_t HksOpensslDhGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) +{ + int32_t ret; + int nid = 0; + ret = HksOpensslGetNid(spec->keyLen, &nid); + if (ret != HKS_SUCCESS) { + return ret; + } + + DH *dh = DH_new_by_nid(nid); + if (dh == NULL) { + HksLogOpensslError(); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + if (DH_generate_key(dh) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + DH_free(dh); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + ret = DhSaveKeyMaterial(dh, spec->keyLen, key); + + DH_free(dh); + + return ret; +} +#endif /* HKS_SUPPORT_DH_GENERATE_KEY */ + +#ifdef HKS_SUPPORT_DH_GET_PUBLIC_KEY +int32_t HksOpensslGetDhPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)input->data; + if (input->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return HKS_ERROR_INVALID_ARGUMENT; + } + if (output->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return HKS_ERROR_INVALID_ARGUMENT; + } + + (void)memcpy_s(output->data, output->size, input->data, sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize); + ((struct KeyMaterialDh *)output->data)->priKeySize = 0; + ((struct KeyMaterialDh *)output->data)->reserved = 0; + output->size = sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize; + + return HKS_SUCCESS; +} +#endif /* HKS_SUPPORT_DH_GET_PUBLIC_KEY */ + +#ifdef HKS_SUPPORT_DH_AGREE_KEY +int32_t HksOpensslDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, + const struct HksKeySpec *spec, struct HksBlob *sharedKey) +{ + int32_t ret; + if (HKS_KEY_BYTES(spec->keyLen) > sharedKey->size) { + return HKS_ERROR_INVALID_KEY_SIZE; + } + + struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data; + BIGNUM *pub = BN_bin2bn(pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL); + if (pub == NULL) { + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + DH *dh = InitDhStruct(nativeKey, true); + if (dh == NULL) { + BN_free(pub); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + uint8_t computeKey[DH_size(dh)]; + + if (DH_compute_key_padded(computeKey, pub, dh) <= 0) { + HksLogOpensslError(); + BN_free(pub); + DH_free(dh); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (HKS_KEY_BYTES(spec->keyLen) > DH_size(dh)) { + ret = HKS_ERROR_INVALID_KEY_SIZE; + } else { + (void)memcpy_s(sharedKey->data, sharedKey->size, computeKey, HKS_KEY_BYTES(spec->keyLen)); + sharedKey->size = DH_size(dh); + ret = HKS_SUCCESS; + } + + BN_free(pub); + DH_free(dh); + return ret; +} +#endif /* HKS_SUPPORT_DH_AGREE_KEY */ + +#endif /* HKS_SUPPORT_DH_C */ \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c index a2690a1c..ae121a28 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c @@ -42,14 +42,53 @@ static uint32_t GetOpensslKeyBlocksLen(uint32_t keylen) return (keylen + OPENSSL_KEY_BLOCK - 1) / OPENSSL_KEY_BLOCK * OPENSSL_KEY_BLOCK; } +static DSA *InitDsaStruct(const struct HksBlob *key, const bool needPrivateExponent) +{ + DSA *dsa = DSA_new(); + if (dsa == NULL) { + return NULL; + } + + const struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)(key->data); + uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)]; + uint32_t offset = sizeof(*keyMaterial); + BIGNUM *x = NULL; + if (needPrivateExponent == true) { + if (keyMaterial->xSize == 0) { + return NULL; + } else { + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->xSize); + x = BN_bin2bn(buff, keyMaterial->xSize, NULL); + } + } + offset += keyMaterial->xSize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->ySize); + BIGNUM *y = BN_bin2bn(buff, keyMaterial->ySize, NULL); + offset += keyMaterial->ySize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->pSize); + BIGNUM *p = BN_bin2bn(buff, keyMaterial->pSize, NULL); + offset += keyMaterial->pSize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->qSize); + BIGNUM *q = BN_bin2bn(buff, keyMaterial->qSize, NULL); + offset += keyMaterial->qSize; + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->gSize); + BIGNUM *g = BN_bin2bn(buff, keyMaterial->gSize, NULL); + + if (DSA_set0_key(dsa, y, x) != HKS_OPENSSL_SUCCESS || DSA_set0_pqg(dsa, p, q, g) != HKS_OPENSSL_SUCCESS) { + DSA_free(dsa); + return NULL; + } + return dsa; +} + #ifdef HKS_SUPPORT_DSA_GENERATE_KEY static void DsaGetKeyParamLen( uint32_t keyLen, uint32_t *xlen, uint32_t *ylen, uint32_t *plen, uint32_t *qlen, uint32_t *glen) { - *xlen = (keyLen > OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + *xlen = (keyLen >= OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; *ylen = keyLen; *plen = keyLen; - *qlen = (keyLen > OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + *qlen = (keyLen >= OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; *glen = keyLen; } @@ -80,8 +119,8 @@ static int32_t DsaKeyMaterialParam(uint8_t *rawMaterial, const DSA *dsa, uint32_ { struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)rawMaterial; keyMaterial->keyAlg = HKS_ALG_DSA; - keyMaterial->keySize = keyLen; - DsaGetKeyParamLen(keyMaterial->keySize, + keyMaterial->keySize = keyLen * HKS_BITS_PER_BYTE; + DsaGetKeyParamLen(keyLen, &keyMaterial->xSize, &keyMaterial->ySize, &keyMaterial->pSize, @@ -207,11 +246,6 @@ int32_t HksOpensslGetDsaPubKey(const struct HksBlob *input, struct HksBlob *outp output->size = sizeof(struct KeyMaterialDsa) + keyMaterial->ySize + keyMaterial->pSize + keyMaterial->qSize + keyMaterial->gSize; - output->data = (uint8_t *)HksMalloc(output->size); - if (output->data == NULL) { - HKS_LOG_E("malloc buffer failed"); - return HKS_ERROR_MALLOC_FAIL; - } struct KeyMaterialDsa *publickeyMaterial = (struct KeyMaterialDsa *)output->data; publickeyMaterial->keyAlg = keyMaterial->keyAlg; @@ -230,4 +264,119 @@ int32_t HksOpensslGetDsaPubKey(const struct HksBlob *input, struct HksBlob *outp return HKS_SUCCESS; } #endif -#endif \ No newline at end of file + +#ifdef HKS_SUPPORT_DSA_SIGN_VERIFY +static EVP_MD_CTX *InitDSAMdCtx(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool signing) +{ + int32_t ret; + + DSA *dsa = InitDsaStruct(key, signing); + if (dsa == NULL) { + HKS_LOG_E("initialize dsa key failed"); + return NULL; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + HksLogOpensslError(); + DSA_free(dsa); + return NULL; + } + + if (EVP_PKEY_assign_DSA(pkey, dsa) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + DSA_free(dsa); + EVP_PKEY_free(pkey); + return NULL; + } + + EVP_MD_CTX *ctx = EVP_MD_CTX_new(); + if (ctx == NULL) { + HksLogOpensslError(); + EVP_PKEY_free(pkey); + return NULL; + } + + if (signing) { + ret = EVP_DigestSignInit(ctx, NULL, GetOpensslAlg(usageSpec->digest), NULL, pkey); + } else { + ret = EVP_DigestVerifyInit(ctx, NULL, GetOpensslAlg(usageSpec->digest), NULL, pkey); + } + if (ret != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(ctx); + return NULL; + } + EVP_PKEY_free(pkey); + + return ctx; +} + +int32_t HksOpensslDsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitDSAMdCtx(key, usageSpec, true); + if (ctx == NULL) { + HKS_LOG_E("initialize ecc md context failed"); + return HKS_ERROR_INVALID_KEY_INFO; + } + + if (EVP_DigestSignUpdate(ctx, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + size_t outLen = 0; + if (EVP_DigestSignFinal(ctx, NULL, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (outLen > signature->size) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + if (EVP_DigestSignFinal(ctx, signature->data, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + signature->size = outLen; + + EVP_MD_CTX_free(ctx); + + return HKS_SUCCESS; +} + +int32_t HksOpensslDsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitDSAMdCtx(key, usageSpec, false); + if (ctx == NULL) { + HKS_LOG_E("initialize ecc md context failed"); + return HKS_ERROR_INVALID_KEY_INFO; + } + + if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + EVP_MD_CTX_free(ctx); + + return HKS_SUCCESS; +} +#endif +#endif diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c index d711459a..353747b1 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c @@ -42,9 +42,9 @@ static int32_t HksOpensslEccCheckKeyLen(uint32_t keyLen) return HKS_SUCCESS; } -static int32_t HksOpensslGetCurveId(const struct HksKeySpec *spec, int *nid) +static int32_t HksOpensslGetCurveId(uint32_t keyLen, int *nid) { - switch (spec->keyLen) { + switch (keyLen) { case HKS_ECC_KEY_SIZE_224: *nid = NID_secp224r1; break; @@ -79,21 +79,21 @@ static int32_t TransEccKeyToKeyBlob( const BIGNUM *priv = EC_KEY_get0_private_key(eccKey); uint32_t offset = sizeof(struct KeyMaterialEcc); - retCode = BN_bn2bin(pubX, rawMaterial + offset + (keyMaterial->xSize - BN_num_bytes(pubX))); + retCode = BN_bn2binpad(pubX, rawMaterial + offset, keyMaterial->xSize); if (retCode <= 0) { HksLogOpensslError(); return HKS_FAILURE; } offset += keyMaterial->xSize; - retCode = BN_bn2bin(pubY, rawMaterial + offset + (keyMaterial->ySize - BN_num_bytes(pubY))); + retCode = BN_bn2binpad(pubY, rawMaterial + offset, keyMaterial->ySize); if (retCode <= 0) { HksLogOpensslError(); return HKS_FAILURE; } offset += keyMaterial->ySize; - retCode = BN_bn2bin(priv, rawMaterial + offset + (keyMaterial->zSize - BN_num_bytes(priv))); + retCode = BN_bn2binpad(priv, rawMaterial + offset, keyMaterial->zSize); if (retCode <= 0) { HksLogOpensslError(); return HKS_FAILURE; @@ -165,7 +165,7 @@ int32_t HksOpensslEccGenerateKey(const struct HksKeySpec *spec, struct HksBlob * int32_t ret = HKS_FAILURE; do { int curveId; - ret = HksOpensslGetCurveId(spec, &curveId); + ret = HksOpensslGetCurveId(spec->keyLen, &curveId); if (ret != HKS_SUCCESS) { break; } @@ -202,11 +202,6 @@ int32_t HksOpensslGetEccPubKey(const struct HksBlob *input, struct HksBlob *outp struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)input->data; output->size = sizeof(struct KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; - output->data = (uint8_t *)HksMalloc(output->size); - if (output->data == NULL) { - HKS_LOG_E("malloc buffer failed"); - return HKS_ERROR_MALLOC_FAIL; - } struct KeyMaterialEcc *publickeyMaterial = (struct KeyMaterialEcc *)output->data; publickeyMaterial->keyAlg = keyMaterial->keyAlg; @@ -299,7 +294,13 @@ static EC_KEY *EccInitKey(const struct HksBlob *keyBlob, bool private) return NULL; } - EC_KEY *eccKey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1); + int nid; + if (HksOpensslGetCurveId(keySize, &nid) != HKS_SUCCESS) { + HKS_LOG_E("get curve id failed"); + return NULL; + } + + EC_KEY *eccKey = EC_KEY_new_by_curve_name(nid); if (eccKey == NULL) { HksLogOpensslError(); return NULL; @@ -384,7 +385,7 @@ int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedK } if (EVP_PKEY_derive(ctx, buffer, &tmpSharedKeySize) != 1) { HksLogOpensslError(); - HksFree(buffer); + HksFree(sharedKey->data); return HKS_FAILURE; } sharedKey->size = (uint32_t)tmpSharedKeySize; @@ -458,9 +459,9 @@ int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct Hks return ret; } -static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, bool sign) +static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest, bool sign) { - const EVP_MD *md = EVP_sha256(); + const EVP_MD *md = GetOpensslAlg(digest); EC_KEY *eccKey = EccInitKey(mainKey, sign); if (eccKey == NULL) { @@ -509,25 +510,26 @@ static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, bool sign) } #ifdef HKS_SUPPORT_ECDSA_SIGN_VERIFY -int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksBlob *message, const struct HksBlob *signature) +int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature) { - EVP_MD_CTX *ctx = InitEccMdCtx(key, false); + EVP_MD_CTX *ctx = InitEccMdCtx(key, usageSpec->digest, false); if (ctx == NULL) { HKS_LOG_E("initialize ecc md context failed"); - return HKS_FAILURE; + return HKS_ERROR_INVALID_KEY_INFO; } if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) <= 0) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } int32_t ret = EVP_DigestVerifyFinal(ctx, signature->data, signature->size); if (ret <= 0) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } EVP_MD_CTX_free(ctx); @@ -537,31 +539,37 @@ int32_t HksOpensslEcdsaVerify(const struct HksBlob *key, const struct HksBlob *m int32_t HksOpensslEcdsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature) { - EVP_MD_CTX *ctx = InitEccMdCtx(key, true); + EVP_MD_CTX *ctx = InitEccMdCtx(key, usageSpec->digest, true); if (ctx == NULL) { HKS_LOG_E("initialize ecc md context failed"); - return HKS_FAILURE; + return HKS_ERROR_INVALID_KEY_INFO; } if (EVP_DigestSignUpdate(ctx, message->data, message->size) <= 0) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } - size_t req = 0; + size_t outLen = 0; - if (EVP_DigestSignFinal(ctx, NULL, &req) <= 0) { + if (EVP_DigestSignFinal(ctx, NULL, &outLen) <= 0) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } - if (EVP_DigestSignFinal(ctx, signature->data, &req) <= 0) { + if (outLen > signature->size) { HksLogOpensslError(); EVP_MD_CTX_free(ctx); - return HKS_FAILURE; + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + if (EVP_DigestSignFinal(ctx, signature->data, &outLen) <= 0) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; } - signature->size = req; + signature->size = outLen; EVP_MD_CTX_free(ctx); return HKS_SUCCESS; diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_engine.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_engine.c index 0d816aef..15394af9 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_engine.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_engine.c @@ -32,6 +32,7 @@ #include "hks_mem.h" #include "hks_openssl_aes.h" #include "hks_openssl_curve25519.h" +#include "hks_openssl_dh.h" #include "hks_openssl_dsa.h" #include "hks_openssl_ecc.h" #include "hks_openssl_ed25519tox25519.h" @@ -163,6 +164,8 @@ static int32_t DecryptCheckParam(const struct HksBlob *key, const struct HksUsag const EVP_MD *GetOpensslAlg(uint32_t alg) { switch (alg) { + case HKS_DIGEST_MD5: + return EVP_md5(); case HKS_DIGEST_SHA1: return EVP_sha1(); case HKS_DIGEST_SHA224: @@ -225,6 +228,10 @@ int32_t HksCryptoHalGetPubKey(const struct HksBlob *keyIn, struct HksBlob *keyOu #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GET_PUBLIC_KEY) case HKS_ALG_ECC: return HksOpensslGetEccPubKey(keyIn, keyOut); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY) + case HKS_ALG_DH: + return HksOpensslGetDhPubKey(keyIn, keyOut); #endif case HKS_ALG_ED25519: return HksOpensslGetEd25519PubKey(keyIn, keyOut); @@ -242,7 +249,16 @@ int32_t HksCryptoHalGetMainKey(const struct HksBlob *message, struct HksBlob *ma int32_t HksCryptoHalHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) { +#if defined(HKS_SUPPORT_HMAC_C) +#if defined(HKS_SUPPORT_HMAC_SHA1) || defined(HKS_SUPPORT_HMAC_SHA224) || defined(HKS_SUPPORT_HMAC_SHA256) || \ + defined(HKS_SUPPORT_HMAC_SHA384) || defined(HKS_SUPPORT_HMAC_SHA512) return HksOpensslHmac(key, digestAlg, msg, mac); +#else + return HKS_ERROR_INVALID_ARGUMENT; +#endif +#else + return HKS_ERROR_NOT_SUPPORTED; +#endif /* HKS_SUPPORT_HMAC_C */ } int32_t HksCryptoHalHash(uint32_t alg, const struct HksBlob *msg, struct HksBlob *hash) @@ -362,28 +378,33 @@ int32_t HksCryptoHalGenerateKey(const struct HksKeySpec *spec, struct HksBlob *k switch (spec->algType) { #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) case HKS_ALG_ECC: + case HKS_ALG_ECDH: return HksOpensslEccGenerateKey(spec, key); #endif #if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) case HKS_ALG_AES: return HksOpensslAesGenerateKey(spec, key); #endif -#if defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined (HKS_SUPPORT_X25519_GENERATE_KEY) +#if defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_X25519_GENERATE_KEY) case HKS_ALG_X25519: case HKS_ALG_ED25519: return HksOpensslCurve25519GenerateKey(spec, key); #endif -#if defined (HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) case HKS_ALG_RSA: return HksOpensslRsaGenerateKey(spec, key); #endif -#if defined (HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) +#if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) case HKS_ALG_HMAC: return HksOpensslHmacGenerateKey(spec, key); #endif -#if defined (HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) case HKS_ALG_DSA: return HksOpensslDsaGenerateKey(spec, key); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GENERATE_KEY) + case HKS_ALG_DH: + return HksOpensslDhGenerateKey(spec, key); #endif default: HKS_LOG_E("Unsupport algType now!"); @@ -404,6 +425,10 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) && defined(HKS_SUPPORT_ECDH_AGREE_KEY) case HKS_ALG_ECDH: return HksOpensslEcdhAgreeKey(nativeKey, pubKey, spec, sharedKey); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_AGREE_KEY) + case HKS_ALG_DH: + return HksOpensslDhAgreeKey(nativeKey, pubKey, spec, sharedKey); #endif case HKS_ALG_X25519: return HksOpensslX25519AgreeKey(nativeKey, pubKey, sharedKey); @@ -428,6 +453,14 @@ int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *u #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) case HKS_ALG_ECC: return HksOpensslEcdsaSign(key, usageSpec, message, signature); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) + case HKS_ALG_RSA: + return HksOpensslRsaSign(key, usageSpec, message, signature); +#endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY) + case HKS_ALG_DSA: + return HksOpensslDsaSign(key, usageSpec, message, signature); #endif case HKS_ALG_ED25519: return HksOpensslEd25519Sign(key, message, signature); @@ -449,7 +482,15 @@ int32_t HksCryptoHalVerify(const struct HksBlob *key, const struct HksUsageSpec switch (usageSpec->algType) { #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDSA_C) && defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) case HKS_ALG_ECC: - return HksOpensslEcdsaVerify(key, message, signature); + return HksOpensslEcdsaVerify(key, usageSpec, message, signature); +#endif +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) + case HKS_ALG_RSA: + return HksOpensslRsaVerify(key, usageSpec, message, signature); +#endif +#if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_SIGN_VERIFY) + case HKS_ALG_DSA: + return HksOpensslDsaVerify(key, usageSpec, message, signature); #endif case HKS_ALG_ED25519: return HksOpensslEd25519Verify(key, message, signature); diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hash.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hash.c index 72a1902d..55f69546 100644 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hash.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hash.c @@ -24,6 +24,8 @@ static int32_t CheckDigestAlg(uint32_t alg) { switch (alg) { + case HKS_DIGEST_SHA1: + case HKS_DIGEST_SHA224: case HKS_DIGEST_SHA256: case HKS_DIGEST_SHA384: case HKS_DIGEST_SHA512: diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hmac.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hmac.c index 3e4f3f89..deaf1763 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hmac.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_hmac.c @@ -13,6 +13,14 @@ * limitations under the License. */ +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#ifdef HKS_SUPPORT_HMAC_C + #include "hks_openssl_hmac.h" #include @@ -45,6 +53,10 @@ static int32_t HmacCheckBuffer(const struct HksBlob *key, const struct HksBlob * static uint32_t HmacGetDigestLen(uint32_t alg) { switch (alg) { + case HKS_DIGEST_SHA1: + return HKS_DIGEST_SHA1_LEN; + case HKS_DIGEST_SHA224: + return HKS_DIGEST_SHA224_LEN; case HKS_DIGEST_SHA256: return HKS_DIGEST_SHA256_LEN; case HKS_DIGEST_SHA384: @@ -62,6 +74,7 @@ static int32_t HmacGenKeyCheckParam(const struct HksKeySpec *spec) return HKS_SUCCESS; } +#ifdef HKS_SUPPORT_HMAC_GENERATE_KEY int32_t HksOpensslHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) { if (HmacGenKeyCheckParam(spec) != HKS_SUCCESS) { @@ -95,15 +108,18 @@ int32_t HksOpensslHmacGenerateKey(const struct HksKeySpec *spec, struct HksBlob } return ret; } +#endif /* HKS_SUPPORT_HMAC_GENERATE_KEY */ -static int32_t HmacCheckParam(const struct HksBlob *key, uint32_t alg, - const struct HksBlob *msg, const struct HksBlob *mac) +static int32_t HmacCheckParam( + const struct HksBlob *key, uint32_t alg, const struct HksBlob *msg, const struct HksBlob *mac) { if (HmacCheckBuffer(key, msg, mac) != HKS_SUCCESS) { HKS_LOG_E("Invalid Buffer Info"); return HKS_ERROR_INVALID_ARGUMENT; } - if ((alg != HKS_DIGEST_SHA256) && (alg != HKS_DIGEST_SHA384) && (alg != HKS_DIGEST_SHA512)) { + + if ((alg != HKS_DIGEST_SHA1) && (alg != HKS_DIGEST_SHA224) && (alg != HKS_DIGEST_SHA256) && + (alg != HKS_DIGEST_SHA384) && (alg != HKS_DIGEST_SHA512)) { HKS_LOG_E("Invalid alg(0x%x)", alg); return HKS_ERROR_INVALID_ARGUMENT; } @@ -116,8 +132,9 @@ static int32_t HmacCheckParam(const struct HksBlob *key, uint32_t alg, return HKS_SUCCESS; } -int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, - struct HksBlob *mac) +#if defined(HKS_SUPPORT_HMAC_SHA1) || defined(HKS_SUPPORT_HMAC_SHA224) || defined(HKS_SUPPORT_HMAC_SHA256) || \ + defined(HKS_SUPPORT_HMAC_SHA384) || defined(HKS_SUPPORT_HMAC_SHA512) +int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) { if (HmacCheckParam(key, digestAlg, msg, mac) != HKS_SUCCESS) { return HKS_ERROR_INVALID_ARGUMENT; @@ -136,3 +153,5 @@ int32_t HksOpensslHmac(const struct HksBlob *key, uint32_t digestAlg, const stru } return HKS_SUCCESS; } +#endif /* HKS_SUPPORT_HMAC_SHA1 */ +#endif /* HKS_SUPPORT_HMAC_C */ \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c index 6afa62b3..218a2e7f 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c @@ -47,21 +47,16 @@ static int32_t RsaGenKeyCheckParam(const struct HksKeySpec *spec) } } -static int32_t GetRsaPadding(uint32_t padding, uint32_t *rsaPadding) +static int32_t RsaCheckKeyMaterial(const struct HksBlob *key) { - switch (padding) { - case HKS_PADDING_NONE: - *rsaPadding = RSA_NO_PADDING; - return HKS_SUCCESS; - case HKS_PADDING_PKCS1_V1_5: - *rsaPadding = RSA_PKCS1_PADDING; - return HKS_SUCCESS; - case HKS_PADDING_OAEP: - *rsaPadding = RSA_PKCS1_OAEP_PADDING; - return HKS_SUCCESS; - default: - return HKS_FAILURE; + const struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)(key->data); + if (keyMaterial->keyAlg != HKS_ALG_RSA) { + return HKS_ERROR_INVALID_KEY_INFO; + } + if (key->size != sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize) { + return HKS_ERROR_INVALID_KEY_INFO; } + return HKS_SUCCESS; } static RSA *InitRsaStruct(const struct HksBlob *key, const bool needPrivateExponent) @@ -85,6 +80,7 @@ static RSA *InitRsaStruct(const struct HksBlob *key, const bool needPrivateExpon RSA *rsa = RSA_new(); int32_t ret = RSA_set0_key(rsa, n, e, d); if (ret != HKS_OPENSSL_SUCCESS) { + RSA_free(rsa); return NULL; } @@ -121,7 +117,7 @@ static int32_t RsaSaveKeyMaterial(const RSA *rsa, const uint32_t keySize, struct memcpy_s(rawMaterial + offset, keyByteLen, tmp_buff, keyMaterial->dSize); key->data = rawMaterial; - key->size = rawMaterialLen; + key->size = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize; return HKS_SUCCESS; } @@ -138,27 +134,27 @@ int32_t HksOpensslRsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob * BN_set_word(e, RSA_F4); - RSA_generate_key_ex(rsa, spec->keyLen, e, NULL); + if (RSA_generate_key_ex(rsa, spec->keyLen, e, NULL) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + BN_free(e); + RSA_free(rsa); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + BN_free(e); int32_t ret = RsaSaveKeyMaterial(rsa, spec->keyLen, key); - BN_free(e); RSA_free(rsa); return ret; } -#endif +#endif /* HKS_SUPPORT_RSA_GENERATE_KEY */ #ifdef HKS_SUPPORT_RSA_GET_PUBLIC_KEY int32_t HksOpensslGetRsaPubKey(const struct HksBlob *input, struct HksBlob *output) { struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)input->data; output->size = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize; - output->data = (uint8_t *)HksMalloc(output->size); - if (output->data == NULL) { - HKS_LOG_E("malloc buffer failed"); - return HKS_ERROR_MALLOC_FAIL; - } struct KeyMaterialRsa *publickeyMaterial = (struct KeyMaterialRsa *)output->data; publickeyMaterial->keyAlg = keyMaterial->keyAlg; @@ -174,12 +170,34 @@ int32_t HksOpensslGetRsaPubKey(const struct HksBlob *input, struct HksBlob *outp return HKS_SUCCESS; } -#endif +#endif /* HKS_SUPPORT_RSA_GET_PUBLIC_KEY */ #ifdef HKS_SUPPORT_RSA_CRYPT +static int32_t GetRsaCryptPadding(uint32_t padding, uint32_t *rsaPadding) +{ + switch (padding) { + case HKS_PADDING_NONE: + *rsaPadding = RSA_NO_PADDING; + return HKS_SUCCESS; + case HKS_PADDING_PKCS1_V1_5: + *rsaPadding = RSA_PKCS1_PADDING; + return HKS_SUCCESS; + case HKS_PADDING_OAEP: + *rsaPadding = RSA_PKCS1_OAEP_PADDING; + return HKS_SUCCESS; + default: + return HKS_FAILURE; + } +} + static EVP_PKEY_CTX *InitEvpPkeyCtx(const struct HksBlob *key, bool encrypt) { - int32_t ret; + int32_t ret = RsaCheckKeyMaterial(key); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("check key material failed"); + return NULL; + } + RSA *rsa = InitRsaStruct(key, !encrypt); if (rsa == NULL) { HKS_LOG_E("initialize rsa key failed"); @@ -188,6 +206,7 @@ static EVP_PKEY_CTX *InitEvpPkeyCtx(const struct HksBlob *key, bool encrypt) EVP_PKEY *pkey = EVP_PKEY_new(); if (pkey == NULL) { + RSA_free(rsa); HksLogOpensslError(); return NULL; } @@ -195,6 +214,7 @@ static EVP_PKEY_CTX *InitEvpPkeyCtx(const struct HksBlob *key, bool encrypt) ret = EVP_PKEY_assign_RSA(pkey, rsa); if (ret != HKS_OPENSSL_SUCCESS) { HksLogOpensslError(); + RSA_free(rsa); EVP_PKEY_free(pkey); return NULL; } @@ -217,6 +237,7 @@ static EVP_PKEY_CTX *InitEvpPkeyCtx(const struct HksBlob *key, bool encrypt) return NULL; } + EVP_PKEY_free(pkey); return ctx; } @@ -224,7 +245,7 @@ static int32_t HksOpensslRsaCryptInit(EVP_PKEY_CTX *ctx, const struct HksUsageSp { int32_t ret; uint32_t padding = 0; - if (GetRsaPadding(usageSpec->padding, &padding) != HKS_SUCCESS) { + if (GetRsaCryptPadding(usageSpec->padding, &padding) != HKS_SUCCESS) { HKS_LOG_E("Unsupport padding."); return HKS_FAILURE; } @@ -290,7 +311,154 @@ int32_t HksOpensslRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec } cipherText->size = outLen; + EVP_PKEY_CTX_free(ctx); return HKS_SUCCESS; } -#endif -#endif \ No newline at end of file +#endif /* HKS_SUPPORT_RSA_CRYPT */ + +#ifdef HKS_SUPPORT_RSA_SIGN_VERIFY +static int32_t GetRsaSignPadding(uint32_t padding, uint32_t *rsaPadding) +{ + switch (padding) { + case HKS_PADDING_PKCS1_V1_5: + *rsaPadding = RSA_PKCS1_PADDING; + return HKS_SUCCESS; + case HKS_PADDING_PSS: + *rsaPadding = RSA_PKCS1_PSS_PADDING; + return HKS_SUCCESS; + default: + return HKS_FAILURE; + } +} + +static EVP_MD_CTX *InitRSAMdCtx(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool signing) +{ + int32_t ret = HKS_FAILURE; + uint32_t opensslPadding = 0; + + if (GetRsaSignPadding(usageSpec->padding, &opensslPadding) != HKS_SUCCESS) { + HKS_LOG_E("Unsupport padding."); + return NULL; + } + + RSA *rsa = NULL; + EVP_PKEY *pkey = NULL; + EVP_MD_CTX *ctx = NULL; + + do { + rsa = InitRsaStruct(key, signing); + if (rsa == NULL) { + HKS_LOG_E("initialize rsa key failed"); + break; + } + + pkey = EVP_PKEY_new(); + if (pkey == NULL) { + break; + } + + if (EVP_PKEY_assign_RSA(pkey, rsa) != HKS_OPENSSL_SUCCESS) { + break; + } + rsa = NULL; + + ctx = EVP_MD_CTX_new(); + if (ctx == NULL) { + break; + } + + if (signing) { + ret = EVP_DigestSignInit(ctx, NULL, GetOpensslAlg(usageSpec->digest), NULL, pkey); + } else { + ret = EVP_DigestVerifyInit(ctx, NULL, GetOpensslAlg(usageSpec->digest), NULL, pkey); + } + if (ret != HKS_OPENSSL_SUCCESS) { + break; + } + + if (usageSpec->padding == HKS_PADDING_PSS) { + if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(ctx), opensslPadding) != HKS_OPENSSL_SUCCESS) { + break; + } + } + ret = HKS_SUCCESS; + } while (0); + + SELF_FREE_PTR(rsa, RSA_free); + SELF_FREE_PTR(pkey, EVP_PKEY_free); + if (ret != HKS_SUCCESS) { + HksLogOpensslError(); + SELF_FREE_PTR(ctx, EVP_MD_CTX_free); + } + + return ctx; +} + +int32_t HksOpensslRsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitRSAMdCtx(key, usageSpec, true); + if (ctx == NULL) { + HKS_LOG_E("initialize rsa md context failed"); + return HKS_ERROR_INVALID_KEY_INFO; + } + + if (EVP_DigestSignUpdate(ctx, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + size_t outLen = 0; + if (EVP_DigestSignFinal(ctx, NULL, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (outLen > signature->size) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_BUFFER_TOO_SMALL; + } + + if (EVP_DigestSignFinal(ctx, signature->data, &outLen) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + signature->size = outLen; + + EVP_MD_CTX_free(ctx); + + return HKS_SUCCESS; +} + +int32_t HksOpensslRsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, + const struct HksBlob *message, const struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitRSAMdCtx(key, usageSpec, false); + if (ctx == NULL) { + HKS_LOG_E("initialize rsa md context failed"); + return HKS_ERROR_INVALID_KEY_INFO; + } + + if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) != HKS_OPENSSL_SUCCESS) { + HksLogOpensslError(); + EVP_MD_CTX_free(ctx); + return HKS_ERROR_CRYPTO_ENGINE_ERROR; + } + + EVP_MD_CTX_free(ctx); + + return HKS_SUCCESS; +} +#endif /* HKS_SUPPORT_RSA_SIGN_VERIFY */ + +#endif /* HKS_SUPPORT_RSA_C */ \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/BUILD.gn b/frameworks/huks_standard/main/crypto_engine/test/unittest/BUILD.gn index 3327b5b9..f5cf6b7a 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/BUILD.gn +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/BUILD.gn @@ -36,8 +36,14 @@ ohos_unittest("crypto_engine_unit_test") { "hks_crypto_hal_aes_key.cpp", "hks_crypto_hal_common.cpp", "hks_crypto_hal_common.h", + "hks_crypto_hal_dh.cpp", + "hks_crypto_hal_dh_agree.cpp", "hks_crypto_hal_dsa_key.cpp", + "hks_crypto_hal_dsa_sign.cpp", "hks_crypto_hal_ecc_key.cpp", + "hks_crypto_hal_ecdh_agree.cpp", + "hks_crypto_hal_ecdsa_sign.cpp", + "hks_crypto_hal_hmac_hmac.cpp", "hks_crypto_hal_hmac_key.cpp", "hks_crypto_hal_rsa_cipher.cpp", "hks_crypto_hal_rsa_decrypt.cpp", @@ -45,6 +51,8 @@ ohos_unittest("crypto_engine_unit_test") { "hks_crypto_hal_rsa_key.cpp", "hks_crypto_hal_rsa_oaep_decrypt.cpp", "hks_crypto_hal_rsa_oaep_encrypt.cpp", + "hks_crypto_hal_rsa_pkcs1_sign.cpp", + "hks_crypto_hal_rsa_pss_sign.cpp", ] if (use_crypto_lib == "openssl") { sources += [ "hks_crypto_hal_api_openssl.cpp" ] @@ -75,13 +83,6 @@ ohos_unittest("crypto_engine_unit_test") { deps += [ "//base/security/huks/frameworks/huks_standard/main/crypto_engine/mbedtls:libhuks_mbedtls_standard_static" ] } - external_deps = [ - "hiviewdfx_hilog_native:libhilog", - "ipc:ipc_core", - "safwk:system_ability_fwk", - "samgr_standard:samgr_proxy", - ] - subsystem_name = "security" part_name = "huks_standard" } diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp index 0b958bd3..97a34a60 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp @@ -44,11 +44,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_001, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -65,16 +65,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_001, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -109,11 +109,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_002, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -130,16 +130,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_002, Function | SmallTest uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -174,11 +174,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_003, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -195,16 +195,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_003, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -239,7 +239,7 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_004, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, @@ -257,16 +257,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_004, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -299,7 +299,7 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_005, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, @@ -317,16 +317,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_005, Function | SmallTest uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -360,14 +360,14 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_006, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagLenEnc = 16; @@ -386,16 +386,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_006, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&AES_128_GCM_KEY[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&AES_128_GCM_KEY[2 * ii]); } @@ -428,11 +428,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_007, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -449,16 +449,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_007, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -493,11 +493,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_008, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -514,16 +514,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_008, Function | SmallTest uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -558,11 +558,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_009, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -579,16 +579,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_009, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -623,7 +623,7 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_010, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, @@ -641,16 +641,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_010, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -683,7 +683,7 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_011, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, @@ -701,16 +701,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_011, Function | SmallTest uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -723,7 +723,7 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_011, Function | SmallTest EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); + EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); #endif HksFree(key.data); HksFree(message.data); @@ -744,14 +744,14 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_012, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagLenEnc = 16; @@ -770,16 +770,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_012, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&AES_192_GCM_KEY[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&AES_192_GCM_KEY[2 * ii]); } @@ -812,11 +812,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_013, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -833,16 +833,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_013, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -877,11 +877,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_014, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -898,16 +898,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_014, Function | SmallTest uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -942,11 +942,11 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_015, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -963,16 +963,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_015, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1007,7 +1007,7 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_016, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, @@ -1025,16 +1025,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_016, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1067,7 +1067,7 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_017, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, @@ -1085,16 +1085,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_017, Function | SmallTest uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1128,14 +1128,14 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_018, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagLenEnc = 16; @@ -1155,16 +1155,16 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_018, Function | SmallTest uint32_t outLen = dataLen; uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1181,4 +1181,4 @@ HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_018, Function | SmallTest HksFree(inscription.data); HksFree(tagAead.data); } -} // namespace AesCipher \ No newline at end of file +} // namespace AesCipher diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp index 48df877e..d1828a55 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp @@ -36,14 +36,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_001, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -59,12 +59,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_001, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -84,14 +84,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_002, Function | SmallTes const char *keyData = "6b6579306b6579306b6579306b657930"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -108,12 +108,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_002, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -133,14 +133,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_003, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -156,12 +156,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_003, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -181,7 +181,7 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_004, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -201,12 +201,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_004, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -226,7 +226,7 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_005, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -246,12 +246,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_005, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -279,23 +279,23 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_006, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - const char *tagData = "33900fd4c7abd3decfb404681bc1b4a8"; + const char *tagData = "43a345ff5f3af4bb383f999393949acc"; uint32_t tagLen = strlen(keyData) / 2; - HksBlob tagDecrypt = {.size = tagLen, .data = (uint8_t *)HksMalloc(tagLen)}; + HksBlob tagDecrypt = { .size = tagLen, .data = (uint8_t *)HksMalloc(tagLen) }; for (uint32_t ii = 0; ii < tagLen; ii++) { tagDecrypt.data[ii] = ReadHex((const uint8_t *)&tagData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagDec = tagDecrypt; @@ -308,24 +308,25 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_006, Function | SmallTes .algParam = &aeadParam, }; - const char *hexData = "8fed19a5a1ad390f45282672d40c728a19069005ec5f5e2617451bd4a39afa8a"; + const char *hexData = "fd692103d931c663a0371bd250dd883aed48379774bfba64327cc4a3ea19afae"; uint32_t dataLen = strlen(hexData) / 2; uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); HksFree(key.data); HksFree(message.data); HksFree(cipherText.data); + HksFree(tagDecrypt.data); } /** @@ -339,14 +340,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_007, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -362,12 +363,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_007, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -387,14 +388,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_008, Function | SmallTes const char *keyData = "6b6579306b6579306b6579306b6579306b6579306b657930"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -411,12 +412,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_008, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -436,14 +437,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_009, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -459,12 +460,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_009, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -484,7 +485,7 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_010, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -504,12 +505,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_010, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -529,7 +530,7 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_011, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -549,12 +550,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_011, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -582,23 +583,23 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_012, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - const char *tagData = "83892e9d33e71a748fe6d4967423922a"; + const char *tagData = "b3ad99cd7951405f1eeefb4e54783f17"; uint32_t tagLen = strlen(tagData) / 2; - HksBlob tagDecrypt = {.size = tagLen, .data = (uint8_t *)HksMalloc(tagLen)}; + HksBlob tagDecrypt = { .size = tagLen, .data = (uint8_t *)HksMalloc(tagLen) }; for (uint32_t ii = 0; ii < tagLen; ii++) { tagDecrypt.data[ii] = ReadHex((const uint8_t *)&tagData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagDec = tagDecrypt; @@ -611,24 +612,25 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_012, Function | SmallTes .algParam = &aeadParam, }; - const char *hexData = "d947f1e3ad8d208e856ae99c5ca0fb5a1909e1fa142e75a7744722a99c96dd35"; + const char *hexData = "06c34934467ad390f5f54410ac20c875feda920d514c3e43819ce16e1e2e3335"; uint32_t dataLen = strlen(hexData) / 2; uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); HksFree(key.data); HksFree(message.data); HksFree(cipherText.data); + HksFree(tagDecrypt.data); } /** @@ -642,14 +644,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_013, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -665,12 +667,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_013, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -690,14 +692,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_014, Function | SmallTes const char *keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -714,12 +716,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_014, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -739,14 +741,14 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_015, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -762,12 +764,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_015, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -787,7 +789,7 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_016, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -807,12 +809,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_016, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -832,7 +834,7 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_017, Function | SmallTes const char *keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -853,12 +855,12 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_017, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -886,23 +888,23 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_018, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - const char *tagData = "3eb59f99f904c5aab4c9ebb43da81379"; + const char *tagData = "35a956a070d5ed7472a9b66165bcada7"; uint32_t tagLen = strlen(tagData) / 2; - HksBlob tagDecrypt = {.size = tagLen, .data = (uint8_t *)HksMalloc(tagLen)}; + HksBlob tagDecrypt = { .size = tagLen, .data = (uint8_t *)HksMalloc(tagLen) }; for (uint32_t ii = 0; ii < tagLen; ii++) { tagDecrypt.data[ii] = ReadHex((const uint8_t *)&tagData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagDec = tagDecrypt; @@ -915,23 +917,24 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_018, Function | SmallTes .algParam = &aeadParam, }; - const char *hexData = "3f592dd53ed966fb7b08756241cc4582ece1c9e8116c94ae7709c28373de647c"; + const char *hexData = "da047651955c64daa5cac9b0082f1567235e682041061fef12f896ba83bb1fde"; uint32_t dataLen = strlen(hexData) / 2; uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); HksFree(key.data); HksFree(message.data); HksFree(cipherText.data); + HksFree(tagDecrypt.data); } } // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp index 9841c2f5..d69d919f 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp @@ -36,14 +36,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_001, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -59,14 +59,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_001, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -86,14 +86,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_002, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -109,14 +109,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_002, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -136,14 +136,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_003, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -159,14 +159,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_003, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -186,7 +186,7 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_004, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -206,14 +206,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_004, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -233,7 +233,7 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_005, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -253,14 +253,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_005, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -288,17 +288,17 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_006, Function | SmallTes const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagLenEnc = 16; @@ -317,14 +317,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_006, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -345,14 +345,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_007, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -368,14 +368,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_007, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -395,14 +395,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_008, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -418,14 +418,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_008, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -445,14 +445,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_009, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -468,14 +468,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_009, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -495,7 +495,7 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_010, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -515,14 +515,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_010, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -542,7 +542,7 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_011, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -562,14 +562,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_011, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -597,17 +597,17 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_012, Function | SmallTes const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagLenEnc = 16; @@ -626,14 +626,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_012, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -654,14 +654,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_013, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -677,14 +677,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_013, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -704,14 +704,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_014, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, @@ -727,14 +727,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_014, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -754,14 +754,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_015, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; HksUsageSpec usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, @@ -777,14 +777,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_015, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -804,7 +804,7 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_016, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -824,14 +824,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_016, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -851,7 +851,7 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_017, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -871,14 +871,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_017, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -906,17 +906,17 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_018, Function | SmallTes const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } - uint8_t iv[16] = {'0'}; + uint8_t iv[16] = {0}; struct HksCipherParam tagIv; - tagIv.iv = {.size = 16, .data = iv}; + tagIv.iv = { .size = 16, .data = iv }; struct HksAeadParam aeadParam; aeadParam.nonce = tagIv.iv; - aeadParam.aad = {.size = 0, .data = nullptr}; + aeadParam.aad = { .size = 0, .data = nullptr }; aeadParam.payloadLen = 0; aeadParam.tagLenEnc = 16; @@ -935,14 +935,14 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_018, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp index 05b4c2d7..e6205414 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp @@ -40,7 +40,7 @@ HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_001, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) @@ -68,7 +68,7 @@ HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_002, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) @@ -96,7 +96,7 @@ HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_003, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp index a106e36f..f688e182 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp @@ -95,25 +95,25 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTes { int32_t ret; - HksBlob key = {.size = 0, .data = nullptr}; - HksUsageSpec spec = {.algType = 0xffff}; - HksBlob message = {.size = 0, .data = nullptr}; - HksBlob cipherText = {.size = 0, .data = nullptr}; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob cipherText = { .size = 0, .data = nullptr }; + HksBlob tagAead = { .size = 0, .data = nullptr }; uint8_t buff[1] = {0}; ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - key = {.size = 1, .data = buff}; + key = { .size = 1, .data = buff }; ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - message = {.size = 1, .data = buff}; + message = { .size = 1, .data = buff }; ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - cipherText = {.size = 1, .data = buff}; + cipherText = { .size = 1, .data = buff }; ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); @@ -130,24 +130,24 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTes { int32_t ret; - HksBlob key = {.size = 0, .data = nullptr}; - HksUsageSpec spec = {.algType = 0xffff}; - HksBlob message = {.size = 0, .data = nullptr}; - HksBlob cipherText = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob cipherText = { .size = 0, .data = nullptr }; uint8_t buff[1] = {0}; ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - key = {.size = 1, .data = buff}; + key = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - message = {.size = 1, .data = buff}; + message = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - cipherText = {.size = 1, .data = buff}; + cipherText = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); @@ -165,11 +165,11 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTes int32_t ret; uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; - HksBlob key = {.size = 1, .data = buff}; - HksUsageSpec spec = {.algType = HKS_ALG_AES, .mode = 0xffff}; - HksBlob message = {.size = 1, .data = buff}; - HksBlob cipherText = {.size = 1, .data = buff}; - HksBlob tagAead = {.size = 1, .data = buff}; + HksBlob key = { .size = 1, .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + HksBlob tagAead = { .size = 1, .data = buff }; ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret); @@ -189,10 +189,10 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTes int32_t ret; uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; - HksBlob key = {.size = 1, .data = buff}; - HksUsageSpec spec = {.algType = HKS_ALG_AES, .mode = 0xffff}; - HksBlob message = {.size = 1, .data = buff}; - HksBlob cipherText = {.size = 1, .data = buff}; + HksBlob key = { .size = 1, .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); EXPECT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret); @@ -212,10 +212,10 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTes int32_t ret; uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; - HksBlob key = {.size = sizeof(buff), buff}; - HksUsageSpec spec = {.algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PSS}; - HksBlob message = {.size = 1, .data = buff}; - HksBlob cipherText = {.size = 1, .data = buff}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PSS }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); EXPECT_EQ(HKS_ERROR_INVALID_PADDING, ret); @@ -236,11 +236,11 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTes uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; uint8_t iv[20] = {0}; - HksBlob key = {.size = sizeof(buff), buff}; - HksCipherParam cipherParam = {.iv = {.size = sizeof(iv), .data = iv}}; - HksUsageSpec spec = {.algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE}; - HksBlob message = {.size = 1, .data = buff}; - HksBlob cipherText = {.size = 1, .data = buff}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksCipherParam cipherParam = { .iv = { .size = sizeof(iv), .data = iv } }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; spec.algParam = &cipherParam; ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); @@ -259,16 +259,16 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTes uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; uint8_t iv[20] = {0}; HksBlob key; - HksCipherParam cipherParam = {.iv = {.size = sizeof(iv), .data = iv}}; - HksUsageSpec spec = {.algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE}; - HksBlob message = {.size = 1, .data = buff}; - HksBlob cipherText = {.size = 1, .data = buff}; + HksCipherParam cipherParam = { .iv = { .size = sizeof(iv), .data = iv } }; + HksUsageSpec spec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; spec.algParam = &cipherParam; uint32_t keyLen = sizeof(KeyMaterialRsa) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + (HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096) + HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096)); - key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)key.data; keyMaterial->keyAlg = HKS_ALG_RSA; keyMaterial->keySize = HKS_RSA_KEY_SIZE_4096; @@ -305,7 +305,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTes .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_2048, }; - HksBlob key = {.size = 0, .data = NULL}; + HksBlob key = { .size = 0, .data = NULL }; ret = HksCryptoHalGenerateKey(&spec, &key); ASSERT_EQ(ret, HKS_SUCCESS); @@ -313,7 +313,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTes KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)key.data; uint32_t keyOutLen = sizeof(KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize; - HksBlob keyOut = {.size = sizeof(KeyMaterialRsa), .data = (uint8_t *)HksMalloc(keyOutLen)}; + HksBlob keyOut = { .size = sizeof(KeyMaterialRsa), .data = (uint8_t *)HksMalloc(keyOutLen) }; keyMaterial->keySize = 2000; ret = HksCryptoHalGetPubKey(&key, &keyOut); @@ -322,5 +322,159 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTes keyMaterial->keySize = HKS_RSA_KEY_SIZE_2048; ret = HksCryptoHalGetPubKey(&key, &keyOut); ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL); + HKS_FREE_BLOB(keyOut); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_012 + * @tc.name : HksCryptoHalApiMbedtls_012 + * @tc.desc : Using HksMbedtlsEccGenerateKey -- key size is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + }; + HksBlob key = { .size = 0, .data = NULL }; + + spec.keyLen += 1; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_013 + * @tc.name : HksCryptoHalApiMbedtls_013 + * @tc.desc : Using HksMbedtlsGetEccPubKey -- Ecc in/out key is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + }; + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialEcc *keyMaterial = (KeyMaterialEcc *)key.data; + + uint32_t keyOutLen = sizeof(KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; + HksBlob keyOut = { .size = sizeof(KeyMaterialEcc), .data = (uint8_t *)HksMalloc(keyOutLen) }; + + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL); + + key.size -= 1; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_INFO); + key.size += 1; + + keyMaterial->zSize = 0xFFFF; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT); + + keyMaterial->keySize += 1; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); + + HKS_FREE_BLOB(keyOut); + HKS_FREE_BLOB(key); +} + +#ifdef HKS_SUPPORT_DH_C +/** + * @tc.number : HksCryptoHalApiMbedtls_014 + * @tc.name : HksCryptoHalApiMbedtls_014 + * @tc.desc : Using HksMbedtlsDhGenerateKey -- key size is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + }; + HksBlob key = { .size = 0, .data = NULL }; + + spec.keyLen += 1; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_015 + * @tc.name : HksCryptoHalApiMbedtls_015 + * @tc.desc : Using HksMbedtlsGetDhPubKey -- Ecc in/out key is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + }; + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialDh *keyMaterial = (KeyMaterialDh *)key.data; + + uint32_t keyOutLen = sizeof(KeyMaterialDh) + keyMaterial->pubKeySize; + HksBlob keyOut = { .size = sizeof(KeyMaterialDh), .data = (uint8_t *)HksMalloc(keyOutLen) }; + + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL); + + key.size = keyOut.size; + ret = HksCryptoHalGetPubKey(&key, &keyOut); + ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT); + HKS_FREE_BLOB(keyOut); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiMbedtls_016 + * @tc.name : HksCryptoHalApiMbedtls_016 + * @tc.desc : Using HksMbedtlsDhAgreeKey -- Ecc in/out key is invalid. + */ +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + }; + HksBlob key = { .size = 0, .data = NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(ret, HKS_SUCCESS); + + KeyMaterialDh *keyMaterial = (KeyMaterialDh *)key.data; + + uint32_t keyOutLen = HKS_KEY_BYTES(spec.keyLen); + HksBlob sharedKey = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) }; + + keyMaterial->keySize -= 1; + ret = HksCryptoHalAgreeKey(&key, &key, &spec, &sharedKey); + ASSERT_EQ(ret, HKS_ERROR_INVALID_KEY_SIZE); + + sharedKey.size -= 1; + ret = HksCryptoHalAgreeKey(&key, &key, &spec, &sharedKey); + ASSERT_EQ(ret, HKS_ERROR_BUFFER_TOO_SMALL); + HKS_FREE_BLOB(sharedKey); + HKS_FREE_BLOB(key); } +#endif } // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp index 5cd754e1..43a67804 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp @@ -37,7 +37,6 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTes HksKeySpec spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_128, - .algParam = nullptr, }; ret = HksCryptoHalGenerateKey(&spec, NULL); @@ -56,7 +55,6 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTes HksKeySpec spec = { .algType = 0xffff, .keyLen = 0, - .algParam = nullptr, }; HksBlob key = {}; @@ -76,8 +74,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTes HksKeySpec spec = { .algType = HKS_ALG_AES, - .keyLen = 0, - .algParam = nullptr, + .keyLen = 1, }; HksBlob key = {}; @@ -88,6 +85,24 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTes spec.algType = HKS_ALG_RSA; ret = HksCryptoHalGenerateKey(&spec, &key); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.algType = HKS_ALG_ECC; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.algType = HKS_ALG_DSA; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + + spec.algType = HKS_ALG_HMAC; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); + +#ifdef HKS_SUPPORT_DH_C + spec.algType = HKS_ALG_DH; + ret = HksCryptoHalGenerateKey(&spec, &key); + ASSERT_EQ(HKS_ERROR_INVALID_KEY_SIZE, ret); +#endif } /** @@ -99,25 +114,25 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTes { int32_t ret; - HksBlob key = {.size = 0, .data = nullptr}; - HksUsageSpec spec = {.algType = 0xffff}; - HksBlob message = {.size = 0, .data = nullptr}; - HksBlob cipherText = {.size = 0, .data = nullptr}; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob cipherText = { .size = 0, .data = nullptr }; + HksBlob tagAead = { .size = 0, .data = nullptr }; uint8_t buff[1] = {0}; ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - key = {.size = 1, .data = buff}; + key = { .size = 1, .data = buff }; ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - message = {.size = 1, .data = buff}; + message = { .size = 1, .data = buff }; ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - cipherText = {.size = 1, .data = buff}; + cipherText = { .size = 1, .data = buff }; ret = HksCryptoHalEncrypt(&key, nullptr, &message, &cipherText, &tagAead); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); @@ -134,24 +149,24 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTes { int32_t ret; - HksBlob key = {.size = 0, .data = nullptr}; - HksUsageSpec spec = {.algType = 0xffff}; - HksBlob message = {.size = 0, .data = nullptr}; - HksBlob cipherText = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob cipherText = { .size = 0, .data = nullptr }; uint8_t buff[1] = {0}; ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - key = {.size = 1, .data = buff}; + key = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - message = {.size = 1, .data = buff}; + message = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); - cipherText = {.size = 1, .data = buff}; + cipherText = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, nullptr, &message, &cipherText); ASSERT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); @@ -169,11 +184,11 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTes int32_t ret; uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; - HksBlob key = {.size = 1, .data = buff}; - HksUsageSpec spec = {.algType = HKS_ALG_AES, .mode = 0xffff}; - HksBlob message = {.size = 1, .data = buff}; - HksBlob cipherText = {.size = 1, .data = buff}; - HksBlob tagAead = {.size = 1, .data = buff}; + HksBlob key = { .size = 1, .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; + HksBlob tagAead = { .size = 1, .data = buff }; ret = HksCryptoHalEncrypt(&key, &spec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); @@ -205,10 +220,10 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTes int32_t ret; uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; - HksBlob key = {.size = 1, .data = buff}; - HksUsageSpec spec = {.algType = HKS_ALG_AES, .mode = 0xffff}; - HksBlob message = {.size = 1, .data = buff}; - HksBlob cipherText = {.size = 1, .data = buff}; + HksBlob key = { .size = 1, .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = 0xffff }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); EXPECT_EQ(HKS_ERROR_INVALID_ARGUMENT, ret); @@ -233,10 +248,10 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTes int32_t ret; uint8_t buff[HKS_KEY_BYTES(HKS_AES_KEY_SIZE_128)] = {0}; - HksBlob key = {.size = sizeof(buff), .data = buff}; - HksUsageSpec spec = {.algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PSS}; - HksBlob message = {.size = 1, .data = buff}; - HksBlob cipherText = {.size = 1, .data = buff}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec spec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PSS }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob cipherText = { .size = 1, .data = buff }; ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); EXPECT_EQ(HKS_ERROR_CRYPTO_ENGINE_ERROR, ret); @@ -249,4 +264,299 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTes ret = HksCryptoHalDecrypt(&key, &spec, &message, &cipherText); EXPECT_EQ(HKS_FAILURE, ret); } + +/** + * @tc.number : HksCryptoHalApiOpenssl_009 + * @tc.name : HksCryptoHalApiOpenssl_009 + * @tc.desc : Using HksCryptoHalSign -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTest | Level1) +{ + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob signature = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + key = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + message = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + signature = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalSign(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + EXPECT_EQ(HksCryptoHalSign(&key, &spec, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_010 + * @tc.name : HksCryptoHalApiOpenssl_010 + * @tc.desc : Using HksCryptoHalVerify -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTest | Level1) +{ + HksBlob key = { .size = 0, .data = nullptr }; + HksUsageSpec spec = { .algType = 0xffff }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob signature = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + key = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + message = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + signature = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalVerify(&key, nullptr, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + EXPECT_EQ(HksCryptoHalVerify(&key, &spec, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_011 + * @tc.name : HksCryptoHalApiOpenssl_011 + * @tc.desc : RSA Using HksCryptoHalSign -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + }; + + uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_RSA }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); + + signSpec.padding = HKS_PADDING_PSS; + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); + + HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_BUFFER_TOO_SMALL); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_012 + * @tc.name : HksCryptoHalApiOpenssl_012 + * @tc.desc : RSA Using HksCryptoHalVerify -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTest | Level1) +{ + uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_RSA }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); + + signSpec.padding = HKS_PADDING_PSS; + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_013 + * @tc.name : HksCryptoHalApiOpenssl_013 + * @tc.desc : DSA Using HksCryptoHalSign -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + }; + + uint8_t buff[HKS_KEY_BYTES(256)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_DSA }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); + + HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_BUFFER_TOO_SMALL); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_014 + * @tc.name : HksCryptoHalApiOpenssl_014 + * @tc.desc : DSA Using HksCryptoHalVerify -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTest | Level1) +{ + uint8_t buff[HKS_KEY_BYTES(256)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_DSA }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_015 + * @tc.name : HksCryptoHalApiOpenssl_015 + * @tc.desc : ECDSA Using HksCryptoHalSign -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTest | Level1) +{ + uint8_t buff[HKS_KEY_BYTES(HKS_ECC_KEY_SIZE_256)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_ECC }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalSign(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_016 + * @tc.name : HksCryptoHalApiOpenssl_016 + * @tc.desc : ECDSA Using HksCryptoHalVerify -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + }; + + uint8_t buff[HKS_KEY_BYTES(256)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksUsageSpec signSpec = { .algType = HKS_ALG_ECC }; + HksBlob message = { .size = 1, .data = buff }; + HksBlob signature = { .size = 1, .data = buff }; + + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_INVALID_KEY_INFO); + + HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HksCryptoHalVerify(&key, &signSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_017 + * @tc.name : HksCryptoHalApiOpenssl_017 + * @tc.desc : Using HksCryptoHalAgreeKey -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTest | Level1) +{ + HksBlob key = { .size = 0, .data = nullptr }; + HksBlob pubKey = { .size = 0, .data = nullptr }; + HksKeySpec spec = { .algType = 0xffff }; + HksBlob agreeKey = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + key = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + pubKey = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, nullptr, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + agreeKey = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); +} + +/** + * @tc.number : HksCryptoHalApiOpenssl_018 + * @tc.name : HksCryptoHalApiOpenssl_018 + * @tc.desc : ECDH Using HksCryptoHalAgreeKey -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTest | Level1) +{ + HksKeySpec keySpec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + }; + + uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksBlob pubKey = { .size = sizeof(buff), .data = buff }; + HksKeySpec spec = { .algType = HKS_ALG_ECDH }; + HksBlob agreeKey = { .size = sizeof(buff), .data = buff }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_ARGUMENT); + + spec.keyLen = HKS_ECC_KEY_SIZE_256; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_FAILURE); + + HksCryptoHalGenerateKey(&keySpec, &key); + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_FAILURE); + HKS_FREE_BLOB(key); +} + +#ifdef HKS_SUPPORT_DH_C +/** + * @tc.number : HksCryptoHalApiOpenssl_019 + * @tc.name : HksCryptoHalApiOpenssl_019 + * @tc.desc : DH Using HksCryptoHalAgreeKey -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTest | Level1) +{ + HksKeySpec keySpec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + }; + + uint8_t buff[HKS_KEY_BYTES(HKS_DH_KEY_SIZE_2048)] = {0}; + HksBlob key = { .size = sizeof(buff), .data = buff }; + HksBlob pubKey = { .size = sizeof(buff), .data = buff }; + HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096 }; + HksBlob agreeKey = { .size = sizeof(buff), .data = buff }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_INVALID_KEY_SIZE); + + spec.keyLen = 0; + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_CRYPTO_ENGINE_ERROR); + + HksCryptoHalGenerateKey(&keySpec, &key); + EXPECT_EQ(HksCryptoHalAgreeKey(&key, &pubKey, &spec, &agreeKey), HKS_ERROR_CRYPTO_ENGINE_ERROR); + + HKS_FREE_BLOB(key); +} +#endif + +/** + * @tc.number : HksCryptoHalApiOpenssl_020 + * @tc.name : HksCryptoHalApiOpenssl_020 + * @tc.desc : Using HksCryptoHalAgreeKey -- parameter is invalid. + */ +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTest | Level1) +{ + HksBlob key = { .size = 0, .data = nullptr }; + HksBlob message = { .size = 0, .data = nullptr }; + HksBlob signature = { .size = 0, .data = nullptr }; + uint8_t buff[1] = {0}; + + EXPECT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + key = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + message = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + signature = { .size = 1, .data = buff }; + EXPECT_EQ(HksCryptoHalHmac(&key, NULL, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); + + EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA512, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); +} } // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp new file mode 100755 index 00000000..3920f7ba --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifdef HKS_SUPPORT_DH_C +#include +#include + +#include "hks_mem.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_config.h" + +using namespace testing::ext; +namespace { +class HksCryptoHalDh : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalDh_001 + * @tc.name : HksCryptoHalDh_001 + * @tc.desc : Generate Dh-2048 key pair + */ +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_001, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_2048 }; + + HksBlob key = { 0, NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HKS_SUCCESS, ret); + + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalDh_002 + * @tc.name : HksCryptoHalDh_002 + * @tc.desc : Generate Dh-3072 key pair + */ +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_002, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_3072 }; + + HksBlob key = { 0, NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HKS_SUCCESS, ret); + + HKS_FREE_BLOB(key); +} + +/** + * @tc.number : HksCryptoHalDh_003 + * @tc.name : HksCryptoHalDh_003 + * @tc.desc : Generate Dh-4096 key pair + */ +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_003, Function | SmallTest | Level1) +{ + int32_t ret; + + HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096 }; + + HksBlob key = { 0, NULL }; + + ret = HksCryptoHalGenerateKey(&spec, &key); + EXPECT_EQ(HKS_SUCCESS, ret); + + HKS_FREE_BLOB(key); +} +} // namespace +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp new file mode 100755 index 00000000..3253255e --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifdef HKS_SUPPORT_DH_C +#include +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +class HksCryptoHalDhAgree : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalDhAgree_001 + * @tc.name : HksCryptoHalDhAgree_001 + * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-2048 key. + */ +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_001, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); +} + +/** + * @tc.number : HksCryptoHalDhAgree_002 + * @tc.name : HksCryptoHalDhAgree_002 + * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-3072 key. + */ +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_002, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); +} + +/** + * @tc.number : HksCryptoHalDhAgree_003 + * @tc.name : HksCryptoHalDhAgree_003 + * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-4096 key. + */ +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_003, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); +} +} // namespace +#endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp index ab1706e8..3a887002 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp @@ -40,7 +40,7 @@ HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_001, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GENERATE_KEY) @@ -73,7 +73,7 @@ HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Leve .keyLen = 512, }; - HksBlob key = {.size = 0, .data = NULL}; + HksBlob key = { .size = 0, .data = NULL }; ret = HksCryptoHalGenerateKey(&spec, &key); #ifdef _USE_OPENSSL_ @@ -88,7 +88,7 @@ HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Leve uint32_t keyOutLen = sizeof(KeyMaterialDsa) + keyMaterial->ySize + keyMaterial->pSize + keyMaterial->qSize + keyMaterial->gSize; - HksBlob keyOut = {.size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen)}; + HksBlob keyOut = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) }; ret = HksCryptoHalGetPubKey(&key, &keyOut); #ifdef _USE_OPENSSL_ @@ -97,5 +97,7 @@ HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Leve #ifdef _USE_MBEDTLS_ ASSERT_EQ(ret, HKS_ERROR_NOT_SUPPORTED); #endif + HKS_FREE_BLOB(key); + HKS_FREE_BLOB(keyOut); } } // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp new file mode 100755 index 00000000..95e71cfc --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp @@ -0,0 +1,297 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +class HksCryptoHalDsaSign : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalDsaSign_001 + * @tc.name : HksCryptoHalDsaSign_001 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA1 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); + return; +#endif +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +#endif + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(key.data); + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); +} + +/** + * @tc.number : HksCryptoHalDsaSign_002 + * @tc.name : HksCryptoHalDsaSign_002 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA224 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); + return; +#endif +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +#endif + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(key.data); + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); +} + +/** + * @tc.number : HksCryptoHalDsaSign_003 + * @tc.name : HksCryptoHalDsaSign_003 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA256 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); + return; +#endif +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +#endif + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(key.data); + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); +} + +/** + * @tc.number : HksCryptoHalDsaSign_004 + * @tc.name : HksCryptoHalDsaSign_004 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA384 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); + return; +#endif +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +#endif + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(key.data); + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); +} + +/** + * @tc.number : HksCryptoHalDsaSign_005 + * @tc.name : HksCryptoHalDsaSign_005 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA512 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_005, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); + return; +#endif +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +#endif + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(key.data); + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); +} +} // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp index 760f2e86..33db49d1 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp @@ -40,7 +40,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) @@ -68,7 +68,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) @@ -96,7 +96,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) @@ -124,7 +124,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) @@ -151,7 +151,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Leve .keyLen = HKS_ECC_KEY_SIZE_384, }; - HksBlob key = {.size = 0, .data = NULL}; + HksBlob key = { .size = 0, .data = NULL }; ret = HksCryptoHalGenerateKey(&spec, &key); ASSERT_EQ(ret, HKS_SUCCESS); @@ -159,9 +159,11 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Leve KeyMaterialEcc *keyMaterial = (KeyMaterialEcc *)key.data; uint32_t keyOutLen = sizeof(KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; - HksBlob keyOut = {.size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen)}; + HksBlob keyOut = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) }; ret = HksCryptoHalGetPubKey(&key, &keyOut); ASSERT_EQ(ret, HKS_SUCCESS); + HKS_FREE_BLOB(key); + HKS_FREE_BLOB(keyOut); } } // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp new file mode 100755 index 00000000..4bb5cfae --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp @@ -0,0 +1,203 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +class HksCryptoHalEcdhAgree : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalEcdhAgree_001 + * @tc.name : HksCryptoHalEcdhAgree_001 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-224 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }; + + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + spec.algType = HKS_ALG_ECDH; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); +} + +/** + * @tc.number : HksCryptoHalEcdhAgree_002 + * @tc.name : HksCryptoHalEcdhAgree_002 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-256 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }; + + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + spec.algType = HKS_ALG_ECDH; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); +} + +/** + * @tc.number : HksCryptoHalEcdhAgree_003 + * @tc.name : HksCryptoHalEcdhAgree_003 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-384 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }; + + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + spec.algType = HKS_ALG_ECDH; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); +} + +/** + * @tc.number : HksCryptoHalEcdhAgree_004 + * @tc.name : HksCryptoHalEcdhAgree_004 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-521 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_004, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }; + + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + spec.algType = HKS_ALG_ECDH; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); +} +} // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp new file mode 100755 index 00000000..eeddacf8 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp @@ -0,0 +1,1179 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +class HksCryptoHalEcdsaSign : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalEcdsaSign_001 + * @tc.name : HksCryptoHalEcdsaSign_001 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_001, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_002 + * @tc.name : HksCryptoHalEcdsaSign_002 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_002, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_003 + * @tc.name : HksCryptoHalEcdsaSign_003 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_003, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_004 + * @tc.name : HksCryptoHalEcdsaSign_004 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_004, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_005 + * @tc.name : HksCryptoHalEcdsaSign_005 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_005, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_006 + * @tc.name : HksCryptoHalEcdsaSign_006 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_006, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_007 + * @tc.name : HksCryptoHalEcdsaSign_007 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_007, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_008 + * @tc.name : HksCryptoHalEcdsaSign_008 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_008, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_009 + * @tc.name : HksCryptoHalEcdsaSign_009 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_009, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_010 + * @tc.name : HksCryptoHalEcdsaSign_010 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_010, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_011 + * @tc.name : HksCryptoHalEcdsaSign_011 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_011, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_012 + * @tc.name : HksCryptoHalEcdsaSign_012 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_012, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_013 + * @tc.name : HksCryptoHalEcdsaSign_013 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_013, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_014 + * @tc.name : HksCryptoHalEcdsaSign_014 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_014, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_015 + * @tc.name : HksCryptoHalEcdsaSign_015 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_015, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_016 + * @tc.name : HksCryptoHalEcdsaSign_016 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_016, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_017 + * @tc.name : HksCryptoHalEcdsaSign_017 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_017, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_018 + * @tc.name : HksCryptoHalEcdsaSign_018 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_018, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_019 + * @tc.name : HksCryptoHalEcdsaSign_019 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_019, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_020 + * @tc.name : HksCryptoHalEcdsaSign_020 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_020, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_021 + * @tc.name : HksCryptoHalEcdsaSign_021 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_021, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_022 + * @tc.name : HksCryptoHalEcdsaSign_022 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_022, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_023 + * @tc.name : HksCryptoHalEcdsaSign_023 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_023, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalEcdsaSign_024 + * @tc.name : HksCryptoHalEcdsaSign_024 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_024, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} +} // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp new file mode 100755 index 00000000..d1b25956 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +class HksCryptoHalHmacHmac : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalHmacHmac_001 + * @tc.name : HksCryptoHalHmacHmac_001 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA1 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_001, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA1, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalHmacHmac_002 + * @tc.name : HksCryptoHalHmacHmac_002 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA224 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_002, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA224, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalHmacHmac_003 + * @tc.name : HksCryptoHalHmacHmac_003 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA256 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_003, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA256, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalHmacHmac_004 + * @tc.name : HksCryptoHalHmacHmac_004 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA384 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_004, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA384, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalHmacHmac_005 + * @tc.name : HksCryptoHalHmacHmac_005 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA512 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_005, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + + EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA512, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); +} +} // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp index 5fed000d..ef7c8ed7 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp @@ -40,7 +40,7 @@ HWTEST_F(HksCryptoHalHmacKey, HksCryptoHalHmacKey_001, Function | SmallTest | Le .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp index b86d3eeb..d44c6a3e 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp @@ -65,7 +65,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_001, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -84,16 +84,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_001, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -101,7 +101,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_001, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); #if defined(_USE_OPENSSL_) EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); EXPECT_EQ(inscription.size, message.size); EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); @@ -128,7 +129,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_002, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -148,16 +149,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_002, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -165,7 +166,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_002, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); #if defined(_USE_OPENSSL_) EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); EXPECT_EQ(inscription.size, message.size); EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); @@ -192,7 +194,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_003, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -212,16 +214,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_003, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -229,7 +231,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_003, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); #if defined(_USE_OPENSSL_) EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); EXPECT_EQ(inscription.size, message.size); EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); @@ -256,7 +259,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_004, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -273,16 +276,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_004, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&RSA_2048_NOPADDING_KEY[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&RSA_2048_NOPADDING_KEY[2 * ii]); } @@ -290,7 +293,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_004, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); #if defined(_USE_OPENSSL_) EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); EXPECT_EQ(inscription.size, message.size); EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); @@ -317,7 +321,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_005, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -334,16 +338,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_005, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&RSA_3072_NOPADDING_KEY[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&RSA_3072_NOPADDING_KEY[2 * ii]); } @@ -351,7 +355,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_005, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); #if defined(_USE_OPENSSL_) EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); EXPECT_EQ(inscription.size, message.size); EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); @@ -378,7 +383,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_006, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -395,16 +400,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_006, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&RSA_4096_NOPADDING_KEY[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&RSA_4096_NOPADDING_KEY[2 * ii]); } @@ -412,7 +417,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_006, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); #if defined(_USE_OPENSSL_) EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); EXPECT_EQ(inscription.size, message.size); EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); @@ -441,7 +447,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_007, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -459,16 +465,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_007, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -477,7 +483,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_007, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -504,7 +511,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_008, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -522,16 +529,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_008, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -540,7 +547,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_008, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -567,7 +575,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_009, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -585,16 +593,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_009, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -603,7 +611,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_009, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -630,7 +639,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_010, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -648,16 +657,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_010, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -666,7 +675,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_010, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -693,7 +703,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_011, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -711,16 +721,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_011, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -729,7 +739,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_011, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -756,7 +767,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_012, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -774,16 +785,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_012, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -792,7 +803,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_012, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -819,7 +831,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_013, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -837,16 +849,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_013, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -855,7 +867,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_013, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -882,7 +895,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_014, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -900,16 +913,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_014, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -918,7 +931,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_014, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -945,7 +959,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_015, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -963,16 +977,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_015, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -981,7 +995,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_015, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1008,7 +1023,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_016, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1026,16 +1041,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_016, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1044,7 +1059,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_016, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1071,7 +1087,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_017, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1089,16 +1105,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_017, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1107,7 +1123,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_017, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1134,7 +1151,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_018, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1152,16 +1169,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_018, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1170,7 +1187,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_018, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1197,7 +1215,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_019, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1215,16 +1233,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_019, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1233,7 +1251,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_019, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1260,7 +1279,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_020, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1278,16 +1297,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_020, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1296,7 +1315,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_020, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1323,7 +1343,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_021, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1341,16 +1361,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_021, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1359,7 +1379,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_021, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1386,7 +1407,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_022, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1404,16 +1425,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_022, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1422,7 +1443,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_022, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1449,7 +1471,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_023, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1467,16 +1489,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_023, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1485,7 +1507,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_023, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1512,7 +1535,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_024, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1530,16 +1553,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_024, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1548,7 +1571,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_024, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1575,7 +1599,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_025, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1593,16 +1617,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_025, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1611,7 +1635,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_025, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1638,7 +1663,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_026, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1656,16 +1681,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_026, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1674,7 +1699,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_026, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1701,7 +1727,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_027, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1719,16 +1745,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_027, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1737,7 +1763,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_027, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1764,7 +1791,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_028, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1782,16 +1809,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_028, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1800,7 +1827,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_028, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1827,7 +1855,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_029, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1845,16 +1873,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_029, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1863,7 +1891,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_029, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1890,7 +1919,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_030, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1908,16 +1937,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_030, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1926,7 +1955,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_030, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -1953,7 +1983,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_031, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -1971,16 +2001,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_031, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -1989,7 +2019,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_031, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -2016,7 +2047,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_032, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -2034,16 +2065,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_032, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -2052,7 +2083,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_032, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -2079,7 +2111,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_033, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -2097,16 +2129,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_033, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -2115,7 +2147,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_033, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -2142,7 +2175,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_034, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -2160,16 +2193,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_034, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -2178,7 +2211,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_034, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -2205,7 +2239,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_035, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -2223,16 +2257,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_035, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -2241,7 +2275,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_035, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); @@ -2268,7 +2303,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_036, Function | SmallTest .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec usageSpec = { .algType = HKS_ALG_RSA, @@ -2286,16 +2321,16 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_036, Function | SmallTest uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); uint32_t inscriptionLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; - HksBlob inscription = {.size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen)}; + HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } @@ -2304,7 +2339,8 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_036, Function | SmallTest EXPECT_EQ(HKS_SUCCESS, ret); ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); - message = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksFree(message.data); + message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); EXPECT_EQ(HKS_SUCCESS, ret); EXPECT_EQ(inscription.size, message.size); diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp index 2c3140cb..63f8dc0c 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp @@ -180,7 +180,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_001, Function | SmallTes "0000000000000000000000000000000000000000000000000000000000000000000000010001355e09702ba801411b9fb514f3ad1f99ec" "9283dc1a1d42da1981c9cf36eee92c3154e0b65cd6653c01a0568dec5f969bf6581ca2aa3c572138cfc9a0b2b3535d"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -201,12 +201,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_001, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -240,7 +240,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_002, Function | SmallTes "2083aa742697eda81ceaeb789b4807a6bda1ceb6c661deb59810ddac275d3f4d9a276bc30c65a15fad040d4a41991680ccbf5127548bb6" "153ef468283ba702d8a13655ab5a6c73b6d3dd5accf567a3231900e138af224641"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -262,12 +262,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_002, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -303,7 +303,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_003, Function | SmallTes "4683b5e049028755b56c15879f4b5dc76e57fd0296c1286b347f7387b2f9e8cee0fbd6cf034cd16dffa6cc2f5c1101c1f430c265ea0d5b" "c27a01672405d4f670baf194ccb4ba87a3c5b1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -325,12 +325,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_003, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -357,7 +357,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_004, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_2048_NOPADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_NOPADDING_KEY[2 * ii]); } @@ -382,12 +382,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_004, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -414,7 +414,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_005, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_3072_NOPADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_NOPADDING_KEY[2 * ii]); } @@ -441,12 +441,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_005, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -473,7 +473,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_006, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_4096_NOPADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_NOPADDING_KEY[2 * ii]); } @@ -503,12 +503,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_006, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); #if defined(_USE_OPENSSL_) @@ -540,7 +540,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_007, Function | SmallTes "00000000000000000000000000000000000000000000000000000000000000000000000100012a295cb9b4901720a834afdc9cdc739d9e" "ef5b00ef0053500bcc5afc7ee6158457279c58942bafa28d436be509cd30b841e40cb769efffe8723b70c6f464f599"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -561,12 +561,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_007, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -592,7 +592,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_008, Function | SmallTes "7c72bac069d105cfd00c59f1ace630f57e0d60aa0457ef63c10055a754a9c997acfaf170bb2dc3d21b8e26541ba01ff0b99788b13a553b" "f97c8c71cd149dcb421fb96affc55a6588adb642251bd991ef7d54890950e5b719"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -614,12 +614,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_008, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -647,7 +647,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_009, Function | SmallTes "5e7ec9ee3485a68338c78cc6cd9ceb514aa6b7cce5811306d6d256b3a1d6f6e1a2c309b0d721a0a32566c8e030794c90d984af31685a99" "70960dc0698a51f3e03211fa43b3a4f9336141"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -669,12 +669,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_009, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -693,7 +693,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_010, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_2048_PKCS1PADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_PKCS1PADDING_KEY[2 * ii]); } @@ -718,12 +718,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_010, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -742,7 +742,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_011, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_3072_PKCS1PADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_PKCS1PADDING_KEY[2 * ii]); } @@ -769,12 +769,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_011, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -793,7 +793,7 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_012, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_4096_PKCS1PADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_PKCS1PADDING_KEY[2 * ii]); } @@ -823,12 +823,12 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_012, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp index f1f4dd97..8209b663 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp @@ -173,7 +173,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_001, Function | SmallTes "0000000000000000000000000000000000000000000000000000000000000000000000010001355e09702ba801411b9fb514f3ad1f99ec" "9283dc1a1d42da1981c9cf36eee92c3154e0b65cd6653c01a0568dec5f969bf6581ca2aa3c572138cfc9a0b2b3535d"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -194,14 +194,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_001, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -235,7 +235,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_002, Function | SmallTes "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -257,14 +257,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_002, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -291,7 +291,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_003, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_1024_NOPADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_1024_NOPADDING_KEY[2 * ii]); } @@ -313,14 +313,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_003, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -347,7 +347,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_004, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_2048_NOPADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_NOPADDING_KEY[2 * ii]); } @@ -372,14 +372,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_004, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -406,7 +406,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_005, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_3072_NOPADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_NOPADDING_KEY[2 * ii]); } @@ -433,14 +433,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_005, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -467,7 +467,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_006, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_4096_NOPADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_NOPADDING_KEY[2 * ii]); } @@ -497,14 +497,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_006, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) @@ -536,7 +536,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_007, Function | SmallTes "00000000000000000000000000000000000000000000000000000000000000000000000100012a295cb9b4901720a834afdc9cdc739d9e" "ef5b00ef0053500bcc5afc7ee6158457279c58942bafa28d436be509cd30b841e40cb769efffe8723b70c6f464f599"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -556,14 +556,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_007, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -589,7 +589,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_008, Function | SmallTes "7c72bac069d105cfd00c59f1ace630f57e0d60aa0457ef63c10055a754a9c997acfaf170bb2dc3d21b8e26541ba01ff0b99788b13a553b" "f97c8c71cd149dcb421fb96affc55a6588adb642251bd991ef7d54890950e5b719"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -609,14 +609,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_008, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -644,7 +644,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_009, Function | SmallTes "5e7ec9ee3485a68338c78cc6cd9ceb514aa6b7cce5811306d6d256b3a1d6f6e1a2c309b0d721a0a32566c8e030794c90d984af31685a99" "70960dc0698a51f3e03211fa43b3a4f9336141"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -664,14 +664,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_009, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -706,7 +706,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_010, Function | SmallTes "c836e067948438f8a3c5edded4871baf6acab762e501db5fde6f2ec201072532c109d0a55cdf0e275322ccf326c9a2a6b235d5742067b6" "f7912bf772c9039385ab0a81c0186bf91001"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -726,14 +726,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_010, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -752,7 +752,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_011, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_3072_PKCS1PADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_PKCS1PADDING_KEY[2 * ii]); } @@ -772,14 +772,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_011, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -798,7 +798,7 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_012, Function | SmallTes int32_t ret; uint32_t keyLen = strlen(RSA_4096_PKCS1PADDING_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_PKCS1PADDING_KEY[2 * ii]); } @@ -818,14 +818,14 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_012, Function | SmallTes uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp index 01dc3658..810c5f83 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp @@ -40,7 +40,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_001, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) @@ -68,7 +68,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_002, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) @@ -96,7 +96,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_003, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) @@ -124,7 +124,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_004, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) @@ -152,7 +152,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_005, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) @@ -180,7 +180,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_006, Function | SmallTest | Leve .algParam = nullptr, }; - HksBlob key = {.size = 0, .data = nullptr}; + HksBlob key = { .size = 0, .data = nullptr }; ret = HksCryptoHalGenerateKey(&spec, &key); #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) @@ -207,7 +207,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_007, Function | SmallTest | Leve .keyLen = HKS_RSA_KEY_SIZE_2048, }; - HksBlob key = {.size = 0, .data = NULL}; + HksBlob key = { .size = 0, .data = NULL }; ret = HksCryptoHalGenerateKey(&spec, &key); ASSERT_EQ(ret, HKS_SUCCESS); @@ -215,9 +215,11 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_007, Function | SmallTest | Leve KeyMaterialRsa *keyMaterial = (KeyMaterialRsa *)key.data; uint32_t keyOutLen = sizeof(KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize; - HksBlob keyOut = {.size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen)}; + HksBlob keyOut = { .size = keyOutLen, .data = (uint8_t *)HksMalloc(keyOutLen) }; ret = HksCryptoHalGetPubKey(&key, &keyOut); ASSERT_EQ(ret, HKS_SUCCESS); + HKS_FREE_BLOB(key); + HKS_FREE_BLOB(keyOut); } } // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp index 7a9fa9c1..a7ce58ec 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp @@ -456,7 +456,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_013, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -477,12 +477,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_013, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -508,7 +508,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_014, Function | "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -530,12 +530,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_014, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -563,7 +563,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_015, Function | "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" "5b83ef84097f2112e64d11193da5dfcfbf9a51"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -585,12 +585,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_015, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -609,7 +609,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_016, Function | int32_t ret; uint32_t keyLen = strlen(RSA_2048_OAEPSHA1_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_OAEPSHA1_KEY[2 * ii]); } @@ -634,12 +634,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_016, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -658,7 +658,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_017, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA1_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA1_KEY[2 * ii]); } @@ -685,12 +685,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_017, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -709,7 +709,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_018, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA1_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA1_KEY[2 * ii]); } @@ -739,12 +739,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_018, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -768,7 +768,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_019, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -789,12 +789,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_019, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -820,7 +820,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_020, Function | "676f6eb3c28ca64df047bbbc8ca6b0a99351039377662a560d8b204a5b7c3f85c27525e561dd05c1bbdb5bc9bddede40e55397fc15034d" "d30c4309779e0437e0c14191e04829be3d20448bcdc236eabd23ee05a8d76c0001"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -842,12 +842,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_020, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -875,7 +875,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_021, Function | "9664edba0829789c748ed96740a56894f7f085ce43761b81e00738337061bb7f7fd27318c558f4deff8160c071c7c91c47a3e01950198c" "ff3985125a1ae69abddb80834bafc33944edc1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -897,12 +897,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_021, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -921,7 +921,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_022, Function | int32_t ret; uint32_t keyLen = strlen(RSA_2048_OAEPSHA224_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_OAEPSHA224_KEY[2 * ii]); } @@ -946,12 +946,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_022, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -970,7 +970,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_023, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA224_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA224_KEY[2 * ii]); } @@ -997,12 +997,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_023, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1021,7 +1021,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_024, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA224_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA224_KEY[2 * ii]); } @@ -1051,12 +1051,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_024, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1080,7 +1080,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_025, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1101,12 +1101,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_025, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -1132,7 +1132,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_026, Function | "126be3c4260db7209e6434e3ba599a67e8a10c78e750054d4bb65eb7127c05360d035077ad3cb73e5805aebfd28f2189acfa371768cd18" "c301fc00f0981e1c14d377736068e93e8367c4f7bb0fa5a1aa3e827b2bfc52d595"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1154,12 +1154,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_026, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1187,7 +1187,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_027, Function | "c3f883afbbaa6fb7ee8738ee428b4ca66b9429a0344404b2b7ee2dfe5e8b5e02911b588e1da4f1c966eb061d6cb7fb94553d5119aed7ad" "256eacf50f7179fb619add182443ffc322a601"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1209,12 +1209,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_027, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1233,7 +1233,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_028, Function | int32_t ret; uint32_t keyLen = strlen(RSA_2048_OAEPSHA256_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_OAEPSHA256_KEY[2 * ii]); } @@ -1258,12 +1258,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_028, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1282,7 +1282,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_029, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA256_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA256_KEY[2 * ii]); } @@ -1309,12 +1309,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_029, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1333,7 +1333,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_030, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA256_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA256_KEY[2 * ii]); } @@ -1363,12 +1363,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_030, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1392,7 +1392,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_031, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1413,12 +1413,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_031, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -1444,7 +1444,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_032, Function | "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1466,12 +1466,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_032, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -1499,7 +1499,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_033, Function | "f46b486e3a5bd6f6e594fcc0036be7b34bf6ef1897f8bdc9f5352dd9e47c83ca4a8e8670390cffee57bea3c3529f382d76ea7b8b91889f" "87eeabfe6c35dfb10257df39c31d3467dbd7a1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1521,12 +1521,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_033, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1545,7 +1545,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_034, Function | int32_t ret; uint32_t keyLen = strlen(RSA_2048_OAEP_SHA384) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_OAEP_SHA384[2 * ii]); } @@ -1570,12 +1570,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_034, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1594,7 +1594,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_035, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA384_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA384_KEY[2 * ii]); } @@ -1621,12 +1621,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_035, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1645,7 +1645,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_036, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA384_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA384_KEY[2 * ii]); } @@ -1675,12 +1675,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_036, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1704,7 +1704,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_037, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1725,12 +1725,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_037, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -1756,7 +1756,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_038, Function | "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1778,12 +1778,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_038, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -1811,7 +1811,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_039, Function | "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" "5b83ef84097f2112e64d11193da5dfcfbf9a51"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1833,12 +1833,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_039, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -1857,7 +1857,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_040, Function | int32_t ret; uint32_t keyLen = strlen(RSA_2048_OAEPSHA512_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_OAEPSHA512_KEY[2 * ii]); } @@ -1882,12 +1882,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_040, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1906,7 +1906,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_041, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA512_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA512_KEY[2 * ii]); } @@ -1933,12 +1933,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_041, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1957,7 +1957,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_042, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA512_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA512_KEY[2 * ii]); } @@ -1987,12 +1987,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_042, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_EQ(HKS_SUCCESS, ret); @@ -2016,7 +2016,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_043, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -2037,12 +2037,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_043, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -2068,7 +2068,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_044, Function | "bf31291a682d344f5037e5615c490320c88675cb8e02e025e9386ff30574f9edf998ac313117818357810e80c32a6a122cf1d9163ba9d8" "7e38f7291d3ecc39c5d13e94406de947c860de27ab10e90bccf42f76164ec03381"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -2090,12 +2090,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_044, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -2123,7 +2123,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_045, Function | "f00895edd3d0f80d906760026ece80380d1b2719dd7cf6110fa8949bf22067f8f7d4072d355cb06b20271e25aba9b00730b3f1a549822d" "a6628ca7118bb4d3d05bd1432fd072604cea01"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -2145,12 +2145,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_045, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -2169,7 +2169,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_046, Function | int32_t ret; uint32_t keyLen = strlen(RSA_2048_OAEP_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_OAEP_KEY[2 * ii]); } @@ -2194,12 +2194,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_046, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -2218,7 +2218,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_047, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEP_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEP_KEY[2 * ii]); } @@ -2245,12 +2245,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_047, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); @@ -2269,7 +2269,7 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_048, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEP_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEP_KEY[2 * ii]); } @@ -2299,12 +2299,12 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_048, Function | uint32_t inLen = dataLen; uint32_t outLen = dataLen; - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); EXPECT_NE(HKS_SUCCESS, ret); diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_encrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_encrypt.cpp index b421698d..27aef45b 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_encrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_encrypt.cpp @@ -360,7 +360,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_013, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -380,14 +380,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_013, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -413,7 +413,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_014, Function | "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -433,14 +433,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_014, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -468,7 +468,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_015, Function | "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" "5b83ef84097f2112e64d11193da5dfcfbf9a51"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -488,14 +488,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_015, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -530,7 +530,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_016, Function | "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" "adf95c1f761b56c8ddf2e78e532861cef681"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -550,14 +550,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_016, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -576,7 +576,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_017, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA1_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA1_KEY[2 * ii]); } @@ -596,14 +596,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_017, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -622,7 +622,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_018, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA1_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA1_KEY[2 * ii]); } @@ -642,14 +642,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_018, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -673,7 +673,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_019, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -693,14 +693,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_019, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -726,7 +726,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_020, Function | "676f6eb3c28ca64df047bbbc8ca6b0a99351039377662a560d8b204a5b7c3f85c27525e561dd05c1bbdb5bc9bddede40e55397fc15034d" "d30c4309779e0437e0c14191e04829be3d20448bcdc236eabd23ee05a8d76c0001"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -746,14 +746,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_020, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -781,7 +781,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_021, Function | "9664edba0829789c748ed96740a56894f7f085ce43761b81e00738337061bb7f7fd27318c558f4deff8160c071c7c91c47a3e01950198c" "ff3985125a1ae69abddb80834bafc33944edc1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -801,14 +801,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_021, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -843,7 +843,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_022, Function | "0c0be002f7edc638607ba45647166342b004d1cc7a31a3492d8980b9a3f2151a4aa2cd8bdac7b1652d791e6915730bc9de98ac1a3b5fd8" "2c26ae2da515146886c78090a7aa8c31ecf5"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -863,14 +863,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_022, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -889,7 +889,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_023, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA224_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA224_KEY[2 * ii]); } @@ -909,14 +909,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_023, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -935,7 +935,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_024, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA224_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA224_KEY[2 * ii]); } @@ -955,14 +955,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_024, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -986,7 +986,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_025, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1006,14 +1006,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_025, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -1039,7 +1039,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_026, Function | "126be3c4260db7209e6434e3ba599a67e8a10c78e750054d4bb65eb7127c05360d035077ad3cb73e5805aebfd28f2189acfa371768cd18" "c301fc00f0981e1c14d377736068e93e8367c4f7bb0fa5a1aa3e827b2bfc52d595"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1059,14 +1059,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_026, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1094,7 +1094,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_027, Function | "c3f883afbbaa6fb7ee8738ee428b4ca66b9429a0344404b2b7ee2dfe5e8b5e02911b588e1da4f1c966eb061d6cb7fb94553d5119aed7ad" "256eacf50f7179fb619add182443ffc322a601"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1114,14 +1114,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_027, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1156,7 +1156,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_028, Function | "1c17ac851268117c736d2dd28898c69c0c8467a5588b2c6e1d8bd21bcaacc524da0fafcee2d869aa0047a51c2c7624d4b9400c2b2109c0" "5b2b7d1a9141887cae78911e04a35adfd341"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1176,14 +1176,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_028, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1202,7 +1202,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_029, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA256_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA256_KEY[2 * ii]); } @@ -1222,14 +1222,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_029, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1248,7 +1248,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_030, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA256_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA256_KEY[2 * ii]); } @@ -1268,14 +1268,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_030, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1299,7 +1299,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_031, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1319,14 +1319,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_031, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -1352,7 +1352,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_032, Function | "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1372,14 +1372,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_032, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -1407,7 +1407,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_033, Function | "f46b486e3a5bd6f6e594fcc0036be7b34bf6ef1897f8bdc9f5352dd9e47c83ca4a8e8670390cffee57bea3c3529f382d76ea7b8b91889f" "87eeabfe6c35dfb10257df39c31d3467dbd7a1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1427,14 +1427,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_033, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1469,7 +1469,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_034, Function | "2070924068d97856b56ffaf5d47e643bcbc39d85fa425d93c99905301ff10fc15ec2c2bf49228b69cbb50895ecef1140cb05bbf314157e" "c8c21796b1eebea225357a4a8b89385eb141"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1489,14 +1489,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_034, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1515,7 +1515,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_035, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA384_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA384_KEY[2 * ii]); } @@ -1535,14 +1535,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_035, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1561,7 +1561,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_036, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEP_SHA384) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEP_SHA384[2 * ii]); } @@ -1581,14 +1581,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_036, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1612,7 +1612,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_037, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1632,14 +1632,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_037, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -1665,7 +1665,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_038, Function | "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1685,14 +1685,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_038, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -1720,7 +1720,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_039, Function | "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" "5b83ef84097f2112e64d11193da5dfcfbf9a51"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1740,14 +1740,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_039, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -1782,7 +1782,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_040, Function | "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" "adf95c1f761b56c8ddf2e78e532861cef681"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1802,14 +1802,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_040, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1828,7 +1828,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_041, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEPSHA512_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA512_KEY[2 * ii]); } @@ -1848,14 +1848,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_041, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1874,7 +1874,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_042, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEPSHA512_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA512_KEY[2 * ii]); } @@ -1894,14 +1894,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_042, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_EQ(HKS_SUCCESS, ret); @@ -1925,7 +1925,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_043, Function | "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1945,14 +1945,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_043, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -1978,7 +1978,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_044, Function | "bf31291a682d344f5037e5615c490320c88675cb8e02e025e9386ff30574f9edf998ac313117818357810e80c32a6a122cf1d9163ba9d8" "7e38f7291d3ecc39c5d13e94406de947c860de27ab10e90bccf42f76164ec03381"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -1998,14 +1998,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_044, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -2033,7 +2033,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_045, Function | "f00895edd3d0f80d906760026ece80380d1b2719dd7cf6110fa8949bf22067f8f7d4072d355cb06b20271e25aba9b00730b3f1a549822d" "a6628ca7118bb4d3d05bd1432fd072604cea01"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -2053,14 +2053,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_045, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -2095,7 +2095,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_046, Function | "41a160d15679f4ea3bff56bd505f153e013e26a1475370606ddd05e36b76d7cde176eb62af1a48aae3237b86acb0a8c0ceee45a6ca1318" "6b712e72116fb303775a0a4d8365bf4e35f1"; uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); } @@ -2115,14 +2115,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_046, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -2141,7 +2141,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_047, Function | int32_t ret; uint32_t keyLen = strlen(RSA_3072_OAEP_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEP_KEY[2 * ii]); } @@ -2161,14 +2161,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_047, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); @@ -2187,7 +2187,7 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_048, Function | int32_t ret; uint32_t keyLen = strlen(RSA_4096_OAEP_KEY) / 2; - HksBlob key = {.size = keyLen, .data = (uint8_t *)HksMalloc(keyLen)}; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; for (uint32_t ii = 0; ii < keyLen; ii++) { key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEP_KEY[2 * ii]); } @@ -2207,14 +2207,14 @@ HWTEST_F(HksCryptoHalRsaOaepEncrypt, HksCryptoHalRsaOaepEncrypt_048, Function | uint32_t inLen = dataLen; uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - HksBlob message = {.size = inLen, .data = (uint8_t *)HksMalloc(inLen)}; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; for (uint32_t ii = 0; ii < dataLen; ii++) { message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); } - HksBlob cipherText = {.size = outLen, .data = (uint8_t *)HksMalloc(outLen)}; + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - HksBlob tagAead = {.size = 0, .data = nullptr}; + HksBlob tagAead = { .size = 0, .data = nullptr }; ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); EXPECT_NE(HKS_SUCCESS, ret); diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pkcs1_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pkcs1_sign.cpp new file mode 100755 index 00000000..f24e6ad9 --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pkcs1_sign.cpp @@ -0,0 +1,1947 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +class HksCryptoHalRsaPkcs1Sign : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_001 + * @tc.name : HksCryptoHalRsaPkcs1Sign_001 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_001, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_002 + * @tc.name : HksCryptoHalRsaPkcs1Sign_002 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_002, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_003 + * @tc.name : HksCryptoHalRsaPkcs1Sign_003 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_003, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_004 + * @tc.name : HksCryptoHalRsaPkcs1Sign_004 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_004, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_005 + * @tc.name : HksCryptoHalRsaPkcs1Sign_005 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_005, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_006 + * @tc.name : HksCryptoHalRsaPkcs1Sign_006 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-MD5 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_006, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_MD5, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_007 + * @tc.name : HksCryptoHalRsaPkcs1Sign_007 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_007, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_008 + * @tc.name : HksCryptoHalRsaPkcs1Sign_008 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_008, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_009 + * @tc.name : HksCryptoHalRsaPkcs1Sign_009 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_009, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_010 + * @tc.name : HksCryptoHalRsaPkcs1Sign_010 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_010, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_011 + * @tc.name : HksCryptoHalRsaPkcs1Sign_011 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_011, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_012 + * @tc.name : HksCryptoHalRsaPkcs1Sign_012 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-NONE key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_012, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_013 + * @tc.name : HksCryptoHalRsaPkcs1Sign_013 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_013, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_014 + * @tc.name : HksCryptoHalRsaPkcs1Sign_014 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_014, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_015 + * @tc.name : HksCryptoHalRsaPkcs1Sign_015 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_015, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_016 + * @tc.name : HksCryptoHalRsaPkcs1Sign_016 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_016, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_017 + * @tc.name : HksCryptoHalRsaPkcs1Sign_017 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_017, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_018 + * @tc.name : HksCryptoHalRsaPkcs1Sign_018 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_018, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_019 + * @tc.name : HksCryptoHalRsaPkcs1Sign_019 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_019, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_020 + * @tc.name : HksCryptoHalRsaPkcs1Sign_020 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_020, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_021 + * @tc.name : HksCryptoHalRsaPkcs1Sign_021 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_021, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_022 + * @tc.name : HksCryptoHalRsaPkcs1Sign_022 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_022, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_023 + * @tc.name : HksCryptoHalRsaPkcs1Sign_023 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_023, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_024 + * @tc.name : HksCryptoHalRsaPkcs1Sign_024 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_024, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_025 + * @tc.name : HksCryptoHalRsaPkcs1Sign_025 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_025, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_026 + * @tc.name : HksCryptoHalRsaPkcs1Sign_026 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_026, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_027 + * @tc.name : HksCryptoHalRsaPkcs1Sign_027 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_027, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_028 + * @tc.name : HksCryptoHalRsaPkcs1Sign_028 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_028, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_029 + * @tc.name : HksCryptoHalRsaPkcs1Sign_029 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_029, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_030 + * @tc.name : HksCryptoHalRsaPkcs1Sign_030 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_030, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_031 + * @tc.name : HksCryptoHalRsaPkcs1Sign_031 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_031, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_032 + * @tc.name : HksCryptoHalRsaPkcs1Sign_032 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_032, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_033 + * @tc.name : HksCryptoHalRsaPkcs1Sign_033 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_033, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_034 + * @tc.name : HksCryptoHalRsaPkcs1Sign_034 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_034, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_035 + * @tc.name : HksCryptoHalRsaPkcs1Sign_035 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_035, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_036 + * @tc.name : HksCryptoHalRsaPkcs1Sign_036 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_036, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_037 + * @tc.name : HksCryptoHalRsaPkcs1Sign_037 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_037, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_038 + * @tc.name : HksCryptoHalRsaPkcs1Sign_038 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_038, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_039 + * @tc.name : HksCryptoHalRsaPkcs1Sign_039 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_039, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPkcs1Sign_040 + * @tc.name : HksCryptoHalRsaPkcs1Sign_040 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PKCS1PADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPkcs1Sign, HksCryptoHalRsaPkcs1Sign_040, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} +} // namespace \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pss_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pss_sign.cpp new file mode 100755 index 00000000..ac47a8bd --- /dev/null +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_pss_sign.cpp @@ -0,0 +1,1443 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "hks_config.h" +#include "hks_crypto_hal.h" +#include "hks_crypto_hal_common.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +class HksCryptoHalRsaPssSign : public HksCryptoHalCommon, public testing::Test {}; + +/** + * @tc.number : HksCryptoHalRsaPssSign_001 + * @tc.name : HksCryptoHalRsaPssSign_001 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_001, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + usageSpec.algType = HKS_ALG_RSA; + usageSpec.padding = HKS_PADDING_PSS; + usageSpec.purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_002 + * @tc.name : HksCryptoHalRsaPssSign_002 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_002, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_003 + * @tc.name : HksCryptoHalRsaPssSign_003 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_003, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_004 + * @tc.name : HksCryptoHalRsaPssSign_004 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_004, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_005 + * @tc.name : HksCryptoHalRsaPssSign_005 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_005, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_006 + * @tc.name : HksCryptoHalRsaPssSign_006 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_006, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_007 + * @tc.name : HksCryptoHalRsaPssSign_007 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_007, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + usageSpec.algType = HKS_ALG_RSA; + usageSpec.padding = HKS_PADDING_PSS; + usageSpec.purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_008 + * @tc.name : HksCryptoHalRsaPssSign_008 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_008, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_009 + * @tc.name : HksCryptoHalRsaPssSign_009 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_009, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_010 + * @tc.name : HksCryptoHalRsaPssSign_010 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_010, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_011 + * @tc.name : HksCryptoHalRsaPssSign_011 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_011, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_012 + * @tc.name : HksCryptoHalRsaPssSign_012 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_012, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_013 + * @tc.name : HksCryptoHalRsaPssSign_013 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_013, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_014 + * @tc.name : HksCryptoHalRsaPssSign_014 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_014, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_015 + * @tc.name : HksCryptoHalRsaPssSign_015 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_015, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_016 + * @tc.name : HksCryptoHalRsaPssSign_016 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_016, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_017 + * @tc.name : HksCryptoHalRsaPssSign_017 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_017, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_018 + * @tc.name : HksCryptoHalRsaPssSign_018 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_018, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_019 + * @tc.name : HksCryptoHalRsaPssSign_019 + * @tc.desc : Using HksCryptoHalSign Sign RSA-512-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_019, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_512, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); + return; +#endif +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); +#endif + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_020 + * @tc.name : HksCryptoHalRsaPssSign_020 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_020, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_021 + * @tc.name : HksCryptoHalRsaPssSign_021 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_021, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_022 + * @tc.name : HksCryptoHalRsaPssSign_022 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_022, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_023 + * @tc.name : HksCryptoHalRsaPssSign_023 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_023, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_024 + * @tc.name : HksCryptoHalRsaPssSign_024 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA384 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_024, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_025 + * @tc.name : HksCryptoHalRsaPssSign_025 + * @tc.desc : Using HksCryptoHalSign Sign RSA-768-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_025, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_ERROR_CRYPTO_ENGINE_ERROR); + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); + return; +#endif +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); +#endif + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_026 + * @tc.name : HksCryptoHalRsaPssSign_026 + * @tc.desc : Using HksCryptoHalSign Sign RSA-1024-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_026, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_027 + * @tc.name : HksCryptoHalRsaPssSign_027 + * @tc.desc : Using HksCryptoHalSign Sign RSA-2048-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_027, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_028 + * @tc.name : HksCryptoHalRsaPssSign_028 + * @tc.desc : Using HksCryptoHalSign Sign RSA-3072-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_028, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} + +/** + * @tc.number : HksCryptoHalRsaPssSign_029 + * @tc.name : HksCryptoHalRsaPssSign_029 + * @tc.desc : Using HksCryptoHalSign Sign RSA-4096-PSSPADDING-SHA512 key. + */ +HWTEST_F(HksCryptoHalRsaPssSign, HksCryptoHalRsaPssSign_029, Function | SmallTest | Level1) +{ + HksKeySpec spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + + HksUsageSpec usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PSS, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }; + + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; + + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 512, .data = (uint8_t *)HksMalloc(512) }; + + EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + + struct HksBlob pubKey = { .size = 1044, .data = (uint8_t *)HksMalloc(1044) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/main/include/hks_type.h b/interfaces/innerkits/huks_standard/main/include/hks_type.h index c099426c..c173732b 100755 --- a/interfaces/innerkits/huks_standard/main/include/hks_type.h +++ b/interfaces/innerkits/huks_standard/main/include/hks_type.h @@ -90,6 +90,7 @@ enum HksKeyPurpose { HKS_KEY_PURPOSE_WRAP = 32, /* Usable with wrap key. */ HKS_KEY_PURPOSE_UNWRAP = 64, /* Usable with unwrap key. */ HKS_KEY_PURPOSE_MAC = 128, /* Usable with mac. */ + HKS_KEY_PURPOSE_AGREE = 256, /* Usable with agree. */ }; enum HksKeyDigest { @@ -139,6 +140,10 @@ enum HksKeySize { HKS_AES_KEY_SIZE_512 = 512, HKS_CURVE25519_KEY_SIZE_256 = 256, + + HKS_DH_KEY_SIZE_2048 = 2048, + HKS_DH_KEY_SIZE_3072 = 3072, + HKS_DH_KEY_SIZE_4096 = 4096, }; enum HksKeyAlg { diff --git a/interfaces/innerkits/huks_standard/main/src/hks_api.c b/interfaces/innerkits/huks_standard/main/src/hks_api.c index ac70cf4c..08a46958 100755 --- a/interfaces/innerkits/huks_standard/main/src/hks_api.c +++ b/interfaces/innerkits/huks_standard/main/src/hks_api.c @@ -235,9 +235,14 @@ HKS_API_EXPORT int32_t HksSign(const struct HksBlob *key, const struct HksParamS if ((key == NULL) || (paramSet == NULL) || (srcData == NULL) || (signature == NULL)) { return HKS_ERROR_NULL_POINTER; } - int32_t ret = HksClientSign(key, paramSet, srcData, signature); - HKS_LOG_I("leave sign, result = %d", ret); - return ret; + + struct HksParam *isKeyAlias = NULL; + int32_t ret = HksGetParam(paramSet, HKS_TAG_IS_KEY_ALIAS, &isKeyAlias); + if ((ret == HKS_SUCCESS) && (!isKeyAlias->boolParam)) { + return HksLocalSign(key, paramSet, srcData, signature); + } + + return HksClientSign(key, paramSet, srcData, signature); #else (void)key; (void)paramSet; diff --git a/interfaces/innerkits/huks_standard/test/moduletest/BUILD.gn b/interfaces/innerkits/huks_standard/test/moduletest/BUILD.gn index fbe9778b..dcc38486 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/BUILD.gn +++ b/interfaces/innerkits/huks_standard/test/moduletest/BUILD.gn @@ -23,7 +23,17 @@ ohos_moduletest("huks_mt_test") { "src/hks_aes_decrypt_mt_test.cpp", "src/hks_aes_encrypt_mt_test.cpp", "src/hks_aes_key_mt_test.cpp", + "src/hks_agree_mt_test.cpp", + "src/hks_dsa_test_mt.cpp", + "src/hks_ecc_key_mt_test.cpp", + "src/hks_ecc_sign_mt_test.cpp", + "src/hks_ecc_verify_mt_test.cpp", + "src/hks_hmac_mt_test.cpp", "src/hks_openssl_aes_test_mt.c", + "src/hks_openssl_dh_mt_test.c", + "src/hks_openssl_dsa_sign_test_mt.c", + "src/hks_openssl_ecc_mt_test.c", + "src/hks_openssl_hmac_mt_test.c", "src/hks_openssl_rsa_test_mt.c", "src/hks_rsa_ecb_nopadding_mt.cpp", "src/hks_rsa_ecb_oaep_padding_mt.cpp", @@ -33,6 +43,18 @@ ohos_moduletest("huks_mt_test") { "src/hks_rsa_ecb_oaep_sha384_mt.cpp", "src/hks_rsa_ecb_oaep_sha512_mt.cpp", "src/hks_rsa_ecb_pkcs1_padding_mt.cpp", + "src/hks_rsa_md5_with_rsa_mt.cpp", + "src/hks_rsa_none_with_rsa_mt.cpp", + "src/hks_rsa_sha1_with_rsa_mt.cpp", + "src/hks_rsa_sha1_with_rsa_pss_mt.cpp", + "src/hks_rsa_sha224_with_rsa_mt.cpp", + "src/hks_rsa_sha224_with_rsa_pss_mt.cpp", + "src/hks_rsa_sha256_with_rsa_mt.cpp", + "src/hks_rsa_sha256_with_rsa_pss_mt.cpp", + "src/hks_rsa_sha384_with_rsa_mt.cpp", + "src/hks_rsa_sha384_with_rsa_pss_mt.cpp", + "src/hks_rsa_sha512_with_rsa_mt.cpp", + "src/hks_rsa_sha512_with_rsa_pss_mt.cpp", ] if (use_crypto_lib == "openssl") { diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_aes_test_mt.h b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_aes_test_mt.h index e08570de..86fc3d54 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_aes_test_mt.h +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_aes_test_mt.h @@ -17,13 +17,10 @@ #ifndef HKS_OPENSSL_RSA_TEST_MT_H #define HKS_OPENSSL_RSA_TEST_MT_H -#include +#include +#include "hks_param.h" #include "hks_type.h" -#include "openssl/aes.h" -#include "openssl/bio.h" -#include "openssl/evp.h" -#include "openssl/ossl_typ.h" #include "openssl/rand.h" #ifdef __cplusplus diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dh_mt_test.h b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dh_mt_test.h new file mode 100755 index 00000000..401f357c --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dh_mt_test.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HKS_OPENSSL_DH_TEST_MT_H +#define HKS_OPENSSL_DH_TEST_MT_H + +#include + +#include + +#include +#include +#include + +#include "hks_type.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define DH_FAILED 1 +#define DH_SUCCESS 0 +#define DH_KEY_SIZE 2048 + +int32_t DhGenerateKey(const int keyLen, struct HksBlob *key); + +int32_t DhAgreeKey( + const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey); + +int32_t DhGetDhPubKey(const struct HksBlob *input, struct HksBlob *output); + +int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey); + +int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dsa_sign_test_mt.h b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dsa_sign_test_mt.h new file mode 100755 index 00000000..d5a244e9 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dsa_sign_test_mt.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HKS_OPENSSL_DSA_SIGN_TEST_MT_H +#define HKS_OPENSSL_DSA_SIGN_TEST_MT_H + +#include + +#include +#include + +#include "hks_type.h" +#include "hks_param.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define BIT_NUM_OF_UINT8 8 +#define DSA_FAILED 1 +#define DSA_SUCCESS 0 + +EVP_PKEY *GenerateDsaKey(const uint32_t keySize); + +void DsaGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key); + +int32_t OpensslSignDsa( + const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, enum HksKeyDigest digestType); + +int32_t OpensslVerifyDsa( + const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, enum HksKeyDigest digestType); + +int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey); + +int32_t SaveDsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_ecc_mt_test.h b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_ecc_mt_test.h new file mode 100755 index 00000000..45a31406 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_ecc_mt_test.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HKS_OPENSSL_ECC_TEST_MT_H +#define HKS_OPENSSL_ECC_TEST_MT_H + +#include + +#include + +#include +#include +#include + +#include "hks_type.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ECC_KEYPAIR_CNT 3 +#define ECC_FAILED 1 +#define ECC_SUCCESS 0 +#define ECC_KEY_SIZE 528 +#define ECC_MESSAGE_SIZE 141 + +int32_t ECCGenerateKey(const int keyLen, struct HksBlob *key); + +int32_t EcdsaSign(const struct HksBlob *key, int digest, const struct HksBlob *message, struct HksBlob *signature); + +int32_t EcdsaVerify( + const struct HksBlob *key, int digest, const struct HksBlob *message, const struct HksBlob *signature); + +int32_t GetEccPubKey(const struct HksBlob *input, struct HksBlob *output); + +int32_t X509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey); + +int32_t HksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key); + +int32_t EcdhAgreeKey( + const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_hmac_mt_test.h b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_hmac_mt_test.h new file mode 100755 index 00000000..794fe749 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_hmac_mt_test.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HKS_OPENSSL_HMAC_TEST_MT_H +#define HKS_OPENSSL_HMAC_TEST_MT_H + +#include + +#include + +#include +#include +#include + +#include "hks_type.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define BIT_NUM_OF_UINT8 8 +#define HMAC_KEY_SIZE 512 +#define HMAC_MESSAGE_SIZE 64 +#define HMAC_FAILED 1 +#define HMAC_SUCCESS 0 +#define OUT_PARAMSET_SIZE 2048 + +int32_t HmacGenerateKey(int key_len, struct HksBlob *key); + +int32_t HmacHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif // CIPHER_H \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_rsa_test_mt.h b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_rsa_test_mt.h index c15acdc3..2360f5e6 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_rsa_test_mt.h +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_rsa_test_mt.h @@ -16,16 +16,13 @@ #ifndef HKS_OPENSSL_RSA_TEST_MT_H #define HKS_OPENSSL_RSA_TEST_MT_H -#include +#include -#include -#include #include -#include -#include #include #include "hks_type.h" +#include "hks_param.h" #ifdef __cplusplus extern "C" { @@ -49,6 +46,12 @@ int32_t EncryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct int32_t DecryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct HksBlob *key, int padding, enum HksKeyDigest digestType); +int32_t OpensslSignRsa(const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType); + +int32_t OpensslVerifyRsa(const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType); + #ifdef __cplusplus #if __cplusplus } diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt_test.cpp index 983593e0..fca133c4 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt_test.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt_test.cpp @@ -19,9 +19,6 @@ #include "hks_api.h" #include "hks_mem.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" using namespace testing::ext; namespace { @@ -36,25 +33,25 @@ class HksAesCipherMtTest : public testing::Test {}; HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00100, TestSize.Level1) { uint8_t key[50] = "AES_128_CBC_PKCS7Padding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -64,12 +61,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00100, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -90,25 +87,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00100, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00200, TestSize.Level1) { uint8_t key[50] = "AES_128_CBC_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -118,12 +115,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00200, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -145,25 +142,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00200, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00300, TestSize.Level1) { uint8_t key[50] = "AES_128_CTR_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -173,12 +170,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00300, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -200,25 +197,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00300, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00400, TestSize.Level1) { uint8_t key[50] = "AES_128_ECB_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -228,12 +225,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00400, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -255,25 +252,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00400, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00500, TestSize.Level1) { uint8_t key[50] = "AES_128_ECB_PKCS7Padding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -283,13 +280,14 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00500, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -299,6 +297,14 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00500, TestSize.Level1) free(cipherText.data); free(plainTextDecrypt.data); HksFreeParamSet(¶mInSet); +#endif +#if defined(_USE_MBEDTLS_) + ASSERT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + + free(cipherText.data); + free(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); +#endif } /** @@ -310,29 +316,29 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00500, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00600, TestSize.Level1) { uint8_t key[50] = "AES_128_GCM_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -342,12 +348,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00600, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -369,25 +375,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00600, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00700, TestSize.Level1) { uint8_t key[50] = "AES_192_CBC_PKCS7Padding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -397,12 +403,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00700, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -424,25 +430,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00700, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00800, TestSize.Level1) { uint8_t key[50] = "AES_192_CBC_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -452,12 +458,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00800, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -479,25 +485,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00800, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00900, TestSize.Level1) { uint8_t key[50] = "AES_192_CTR_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -507,12 +513,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00900, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -534,25 +540,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00900, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01000, TestSize.Level1) { uint8_t key[50] = "AES_192_ECB_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -562,12 +568,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01000, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -589,25 +595,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01000, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01100, TestSize.Level1) { uint8_t key[50] = "AES_192_ECB_PKCS7Padding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -617,13 +623,14 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01100, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -633,6 +640,14 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01100, TestSize.Level1) free(cipherText.data); free(plainTextDecrypt.data); HksFreeParamSet(¶mInSet); +#endif +#if defined(_USE_MBEDTLS_) + ASSERT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + + free(cipherText.data); + free(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); +#endif } /** @@ -644,29 +659,29 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01100, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01200, TestSize.Level1) { uint8_t key[50] = "AES_192_GCM_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -676,12 +691,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01200, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -703,25 +718,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01200, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01300, TestSize.Level1) { uint8_t key[50] = "AES_256_CBC_PKCS7Padding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -731,12 +746,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01300, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -758,25 +773,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01300, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01400, TestSize.Level1) { uint8_t key[50] = "AES_256_CBC_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -786,12 +801,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01400, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -813,25 +828,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01400, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01500, TestSize.Level1) { uint8_t key[50] = "AES_256_CTR_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -841,12 +856,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01500, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -868,25 +883,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01500, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01600, TestSize.Level1) { uint8_t key[50] = "AES_256_ECB_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -896,12 +911,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01600, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -923,25 +938,25 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01600, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01700, TestSize.Level1) { uint8_t key[50] = "AES_256_ECB_PKCS7Padding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -951,13 +966,14 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01700, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -967,6 +983,14 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01700, TestSize.Level1) free(cipherText.data); free(plainTextDecrypt.data); HksFreeParamSet(¶mInSet); +#endif +#if defined(_USE_MBEDTLS_) + ASSERT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + + free(cipherText.data); + free(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); +#endif } /** @@ -978,29 +1002,29 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01700, TestSize.Level1) HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01800, TestSize.Level1) { uint8_t key[50] = "AES_256_GCM_NOPadding"; - struct HksBlob alias = {.size = strlen((char *)key), .data = key}; + struct HksBlob alias = { .size = strlen((char *)key), .data = key }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); @@ -1010,12 +1034,12 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01800, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt_test.cpp index cb44fcbc..33f793b3 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt_test.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt_test.cpp @@ -19,9 +19,6 @@ #include "hks_api.h" #include "hks_mem.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" using namespace testing::ext; namespace { @@ -30,37 +27,37 @@ const char TEST_AES_128KEY[] = "This is a AES_128 key"; const char TEST_AES_192KEY[] = "This is a AES_192 key"; const char TEST_AES_256KEY[] = "This is a AES_256 key"; static const struct HksParam AES_DECRYPT_00500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; static const struct HksParam AES_DECRYPT_01100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; static const struct HksParam AES_DECRYPT_01700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; } // namespace @@ -74,25 +71,25 @@ class HksAesDecryptMtTest : public testing::Test {}; */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00100, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -106,13 +103,13 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00100, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -134,25 +131,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00100, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -166,12 +163,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00200, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -193,25 +190,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00200, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00300, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -225,12 +222,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00300, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -252,25 +249,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00300, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -284,12 +281,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00400, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -311,13 +308,13 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00400, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00500, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -332,12 +329,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00500, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); #if defined(_USE_OPENSSL_) @@ -369,29 +366,29 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00500, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -405,14 +402,14 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00600, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), AES_SUCCESS); cipherText.size = 32; (void)memcpy_s(cipherText.data + 16, 16, tagAead.data, 16); @@ -435,25 +432,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00600, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00700, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -467,12 +464,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00700, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -494,25 +491,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00700, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -526,12 +523,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00800, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -553,25 +550,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00800, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00900, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -585,12 +582,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00900, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -612,25 +609,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00900, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -644,12 +641,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01000, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -671,13 +668,13 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01000, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01100, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -692,12 +689,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01100, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); #if defined(_USE_OPENSSL_) @@ -729,29 +726,29 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01100, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -765,14 +762,14 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01200, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), AES_SUCCESS); cipherText.size = 32; (void)memcpy_s(cipherText.data + 16, 16, tagAead.data, 16); @@ -795,25 +792,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01200, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01300, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -827,12 +824,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01300, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -854,25 +851,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01300, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -886,12 +883,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01400, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -913,25 +910,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01400, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01500, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -945,12 +942,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01500, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -971,25 +968,25 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01500, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -1003,12 +1000,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01600, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); @@ -1030,13 +1027,13 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01600, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01700, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -1051,12 +1048,12 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01700, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); #if defined(_USE_OPENSSL_) @@ -1088,29 +1085,29 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01700, TestSize.Level1) */ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -1124,14 +1121,14 @@ HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01800, TestSize.Level1) const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), AES_SUCCESS); cipherText.size = 32; (void)memcpy_s(cipherText.data + 16, 16, tagAead.data, 16); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt_test.cpp index 808d9d8f..02ca3d2a 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt_test.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt_test.cpp @@ -19,9 +19,6 @@ #include "hks_api.h" #include "hks_mem.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" using namespace testing::ext; namespace { @@ -30,37 +27,37 @@ const char TEST_AES_128KEY[] = "This is a AES_128 key"; const char TEST_AES_192KEY[] = "This is a AES_192 key"; const char TEST_AES_256KEY[] = "This is a AES_256 key"; static const struct HksParam AES_ENCRYPT_00500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; static const struct HksParam AES_ENCRYPT_01100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; static const struct HksParam AES_ENCRYPT_01700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; } // namespace class HksAesEncryptMtTest : public testing::Test {}; @@ -73,25 +70,25 @@ class HksAesEncryptMtTest : public testing::Test {}; */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00100, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -104,13 +101,13 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00100, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -132,25 +129,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00100, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -163,12 +160,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00200, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -190,25 +187,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00200, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00300, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -221,12 +218,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00300, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -248,25 +245,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00300, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -279,12 +276,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00400, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -306,13 +303,13 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00400, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00500, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -326,12 +323,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00500, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); #if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); @@ -363,29 +360,29 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00500, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -398,14 +395,14 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00600, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); (void)memcpy_s(tagAead.data, 16, cipherText.data + 16, 16); cipherText.size = 16; @@ -428,25 +425,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00600, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00700, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -459,12 +456,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00700, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -486,25 +483,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00700, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -517,12 +514,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00800, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -544,25 +541,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00800, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00900, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -575,12 +572,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00900, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -602,25 +599,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00900, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -633,12 +630,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01000, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -660,13 +657,13 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01000, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01100, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -680,12 +677,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01100, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); #if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); @@ -717,29 +714,29 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01100, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -752,14 +749,14 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01200, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); (void)memcpy_s(tagAead.data, 16, cipherText.data + 16, 16); cipherText.size = 16; @@ -782,25 +779,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01200, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01300, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -813,12 +810,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01300, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -840,25 +837,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01300, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -871,12 +868,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01400, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -898,25 +895,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01400, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01500, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -929,12 +926,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01500, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -956,25 +953,25 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01500, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -987,12 +984,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01600, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); @@ -1014,13 +1011,13 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01600, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01700, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -1034,12 +1031,12 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01700, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); #if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); @@ -1071,29 +1068,29 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01700, TestSize.Level1) */ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; HksAddParams(paramInSet, &aad, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -1106,14 +1103,14 @@ HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01800, TestSize.Level1) GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); (void)memcpy_s(tagAead.data, 16, cipherText.data + 16, 16); cipherText.size = 16; diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt_test.cpp index e3ceabc1..dd9bb7f0 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt_test.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt_test.cpp @@ -19,9 +19,6 @@ #include "hks_api.h" #include "hks_mem.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" using namespace testing::ext; namespace { @@ -40,25 +37,25 @@ class HksAesKeyMtTest : public testing::Test {}; */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00100, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -72,17 +69,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00100, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -105,25 +102,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00100, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -137,17 +134,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00200, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -170,25 +167,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00200, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00300, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -202,17 +199,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00300, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -235,25 +232,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00300, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -267,17 +264,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00400, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -300,25 +297,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00400, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00500, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -332,17 +329,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00500, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -365,7 +362,7 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00500, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY}; + struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -373,17 +370,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00600, TestSize.Level1) uint8_t iv[IV_SIZE] = {0}; uint8_t aadData[AAD_SIZE] = {0}; struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, - {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}, - {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }, }; struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -397,19 +394,19 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00600, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead), AES_SUCCESS); EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead), AES_SUCCESS); @@ -431,25 +428,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00600, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00700, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -463,17 +460,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00700, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -496,25 +493,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00700, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -528,17 +525,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00800, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -561,25 +558,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00800, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00900, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -593,17 +590,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00900, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -626,25 +623,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00900, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -658,17 +655,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01000, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -691,25 +688,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01000, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01100, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -723,17 +720,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01100, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -756,7 +753,7 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01100, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY}; + struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -764,17 +761,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01200, TestSize.Level1) uint8_t iv[IV_SIZE] = {0}; uint8_t aadData[AAD_SIZE] = {0}; struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, - {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}, - {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }, }; struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -788,19 +785,19 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01200, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead), AES_SUCCESS); EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead), AES_SUCCESS); @@ -822,25 +819,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01200, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01300, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -854,17 +851,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01300, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -887,25 +884,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01300, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -919,17 +916,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01400, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -952,25 +949,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01400, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01500, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -984,17 +981,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01500, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -1017,25 +1014,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01500, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -1049,17 +1046,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01600, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -1082,25 +1079,25 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01600, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01700, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = {.tag = HKS_TAG_IV, .blob = {.size = IV_SIZE, .data = iv}}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; HksAddParams(paramInSet, &tagIv, 1); struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -1114,17 +1111,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01700, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); @@ -1147,7 +1144,7 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01700, TestSize.Level1) */ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY}; + struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1155,17 +1152,17 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01800, TestSize.Level1) uint8_t iv[IV_SIZE] = {0}; uint8_t aadData[AAD_SIZE] = {0}; struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM}, - {.tag = HKS_TAG_NONCE, .blob = {.size = IV_SIZE, .data = iv}}, - {.tag = HKS_TAG_ASSOCIATED_DATA, .blob = {.size = sizeof(aadData), .data = aadData}}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }, }; struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); @@ -1179,19 +1176,19 @@ HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01800, TestSize.Level1) HksParam *symmetricParam = NULL; HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = {.size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size)}; + HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); const char *hexData = "0123456789abcdef"; uint32_t dataLen = strlen(hexData); - HksBlob plainText = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = {.size = 16, .data = (uint8_t *)HksMalloc(16)}; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead), AES_SUCCESS); EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead), AES_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt_test.cpp new file mode 100755 index 00000000..48320683 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt_test.cpp @@ -0,0 +1,1176 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_ecc_mt_test.h" +#include "hks_openssl_dh_mt_test.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char ALISE_KEY[] = "This is a alise key"; +const char BOB_KEY[] = "This is a bob key"; + +int32_t LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, const struct HksParamSet *paramSetIn, + struct HksBlob *priKey, struct HksBlob *pubKey) +{ + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + if (keyLen == 0) { + return HKS_FAILURE; + } + + uint8_t *localData = (uint8_t *)HksMalloc(keyLen); + if (localData == NULL) { + return HKS_FAILURE; + } + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = { .size = keyLen, .data = localData } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + if (HksGenerateKey(authId, paramSetIn, paramOutSet) != HKS_SUCCESS) { + return HKS_FAILURE; + } + + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + priKey->size = priParam->blob.size; + (void)memcpy_s(priKey->data, priKey->size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + pubKey->size = pubParam->blob.size; + (void)memcpy_s(pubKey->data, pubKey->size, pubParam->blob.data, pubParam->blob.size); + + HksFree(localData); + HksFreeParamSet(¶mOutSet); + return HKS_SUCCESS; +} +} // namespace +class HksAgreeMtTest : public testing::Test {}; + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00100 + * @tc.name : HksAgreeMtTest00100 + * @tc.desc : Both parties use huks to generate an ecc224 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00100, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob priKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_224, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_224, &priKeyBob, &pubKeyAlise, &agreeKeyBob), ECC_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(priKeyAlise.data); + free(priKeyBob.data); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00200 + * @tc.name : HksAgreeMtTest00200 + * @tc.desc : Both parties use huks to generate an ecc256 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00200, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob priKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_256, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_256, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_256, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_256, &priKeyBob, &pubKeyAlise, &agreeKeyBob), ECC_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(priKeyAlise.data); + free(priKeyBob.data); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00300 + * @tc.name : HksAgreeMtTest00300 + * @tc.desc : Both parties use huks to generate an ecc384 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00300, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob priKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_384, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_384, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_384, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_384, &priKeyBob, &pubKeyAlise, &agreeKeyBob), ECC_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(priKeyAlise.data); + free(priKeyBob.data); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00400 + * @tc.name : HksAgreeMtTest00400 + * @tc.desc : Both parties use huks to generate an ecc521 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00400, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob priKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_521, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_521, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_521, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_521, &priKeyBob, &pubKeyAlise, &agreeKeyBob), ECC_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(priKeyAlise.data); + free(priKeyBob.data); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00500 + * @tc.name : HksAgreeMtTest00500 + * @tc.desc : Both parties use OpenSSL to generate an ecc224 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00500, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &alise), ECC_SUCCESS); + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &bob), ECC_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00600 + * @tc.name : HksAgreeMtTest00600 + * @tc.desc : Both parties use OpenSSL to generate an ecc256 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00600, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &alise), ECC_SUCCESS); + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &bob), ECC_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00700 + * @tc.name : HksAgreeMtTest00700 + * @tc.desc : Both parties use OpenSSL to generate an ecc384 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00700, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &alise), ECC_SUCCESS); + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &bob), ECC_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00800 + * @tc.name : HksAgreeMtTest00800 + * @tc.desc : Both parties use OpenSSL to generate an ecc521 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00800, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &alise), ECC_SUCCESS); + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &bob), ECC_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest00900 + * @tc.name : HksAgreeMtTest00900 + * @tc.desc : One party uses the key of ECC224 for openssl negotiation, and the other party uses the key of ECC224 + * for huks negotiation + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00900, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &alise), ECC_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + HksBlob x509KeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); + HksBlob x509KeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); + struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_224, &alise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(x509KeyAlise.data); + free(x509KeyBob.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01000 + * @tc.name : HksAgreeMtTest01000 + * @tc.desc : One party uses the key of ECC256 for openssl negotiation, and the other party uses the key of ECC256 + * for huks negotiation + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01000, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &alise), ECC_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + HksBlob x509KeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); + HksBlob x509KeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); + struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_256, &alise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(x509KeyAlise.data); + free(x509KeyBob.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01100 + * @tc.name : HksAgreeMtTest01100 + * @tc.desc : One party uses the key of ECC384 for openssl negotiation, and the other party uses the key of ECC384 + * for huks negotiation + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01100, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &alise), ECC_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + HksBlob x509KeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); + HksBlob x509KeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); + struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_384, &alise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(x509KeyAlise.data); + free(x509KeyBob.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01200 + * @tc.name : HksAgreeMtTest01200 + * @tc.desc : One party uses the key of ECC521 for openssl negotiation, and the other party uses the key of ECC521 + * for huks negotiation + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01200, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &alise), ECC_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + HksBlob x509KeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); + HksBlob x509KeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); + struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); + + HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + + EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_521, &alise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(x509KeyAlise.data); + free(x509KeyBob.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +#ifdef HKS_SUPPORT_DH_C +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01300 + * @tc.name : HksAgreeMtTest01300 + * @tc.desc : Both parties use huks to generate an dh2048 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01300, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob priKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_2048, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_2048, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_2048, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_2048, &priKeyBob, &pubKeyAlise, &agreeKeyBob), DH_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(priKeyAlise.data); + free(priKeyBob.data); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01400 + * @tc.name : HksAgreeMtTest01400 + * @tc.desc : Both parties use huks to generate an dh3072 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01400, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob priKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_3072, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_3072, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_3072, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_3072, &priKeyBob, &pubKeyAlise, &agreeKeyBob), DH_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(priKeyAlise.data); + free(priKeyBob.data); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01500 + * @tc.name : HksAgreeMtTest01500 + * @tc.desc : Both parties use huks to generate an dh4096 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01500, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob priKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_4096, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_4096, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_4096, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_4096, &priKeyBob, &pubKeyAlise, &agreeKeyBob), DH_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(priKeyAlise.data); + free(priKeyBob.data); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01600 + * @tc.name : HksAgreeMtTest01600 + * @tc.desc : Both parties use OpenSSL to generate an dh2048 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01600, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_2048, &alise), DH_SUCCESS); + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_2048, &bob), DH_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01700 + * @tc.name : HksAgreeMtTest01700 + * @tc.desc : Both parties use OpenSSL to generate an dh3072 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01700, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_3072, &alise), DH_SUCCESS); + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_3072, &bob), DH_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01800 + * @tc.name : HksAgreeMtTest01800 + * @tc.desc : Both parties use OpenSSL to generate an dh4096 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01800, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_4096, &alise), DH_SUCCESS); + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_4096, &bob), DH_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest01900 + * @tc.name : HksAgreeMtTest01900 + * @tc.desc : One party uses the key of dh2048 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01900, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_2048, &alise), DH_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + HksBlob x509KeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); + HksBlob x509KeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); + struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_2048, &alise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(x509KeyAlise.data); + free(x509KeyBob.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest02000 + * @tc.name : HksAgreeMtTest02000 + * @tc.desc : One party uses the key of dh3072 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest02000, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_3072, &alise), DH_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + HksBlob x509KeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); + HksBlob x509KeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); + struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_3072, &alise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(x509KeyAlise.data); + free(x509KeyBob.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} + +/** + * @tc.number : HksAgreeMtTest.HksAgreeMtTest02100 + * @tc.name : HksAgreeMtTest02100 + * @tc.desc : One party uses the key of dh4096 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMtTest, HksAgreeMtTest02100, TestSize.Level1) +{ + struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_4096, &alise), DH_SUCCESS); + + struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + HksBlob x509KeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); + HksBlob x509KeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); + struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS); + + HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; + + EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_4096, &alise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKeyAlise.data); + free(x509KeyAlise.data); + free(x509KeyBob.data); + free(pubKeyBob.data); + free(agreeKeyAlise.data); + free(agreeKeyBob.data); +} +#endif +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_test_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_test_mt.cpp new file mode 100755 index 00000000..d40c6277 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_test_mt.cpp @@ -0,0 +1,1730 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_dsa_sign_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for DSA"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_1024 = 1024; +} // namespace + +class HksDsaTestMT : public testing::Test {}; + +static const struct HksParam DSA_00100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00100 + * @tc.name : HksDsaMtTest00100 + * @tc.desc : Test huks generate key (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00100_PARAMS, sizeof(DSA_00100_PARAMS) / sizeof(DSA_00100_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA1), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_00200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00200 + * @tc.name : HksDsaMtTest00200 + * @tc.desc : Test huks sign (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00200, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00200_PARAMS, sizeof(DSA_00200_PARAMS) / sizeof(DSA_00200_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA1), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_00300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00300 + * @tc.name : HksDsaMtTest00300 + * @tc.desc : Test huks sign (1024/SHA1withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00300_PARAMS, sizeof(DSA_00300_PARAMS) / sizeof(DSA_00300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslDsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); + + uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t dsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; + EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA1), 0); + + free(publicKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_00400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00400 + * @tc.name : HksDsaMtTest00400 + * @tc.desc : Test huks Verify (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00400, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00400_PARAMS, sizeof(DSA_00400_PARAMS) / sizeof(DSA_00400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_00500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00500 + * @tc.name : HksDsaMtTest00500 + * @tc.desc : Test huks Verify (1024/SHA1withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00500_PARAMS, sizeof(DSA_00500_PARAMS) / sizeof(DSA_00500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslDsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + DsaGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA1), 0); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); +#else + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +#endif + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslDsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_00600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00600 + * @tc.name : HksDsaMtTest00600 + * @tc.desc : Test huks generate key (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00600, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00600_PARAMS, sizeof(DSA_00600_PARAMS) / sizeof(DSA_00600_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA224), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_00700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00700 + * @tc.name : HksDsaMtTest00700 + * @tc.desc : Test huks sign (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00700_PARAMS, sizeof(DSA_00700_PARAMS) / sizeof(DSA_00700_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA224), 0); + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_00800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00800 + * @tc.name : HksDsaMtTest00800 + * @tc.desc : Test huks sign (1024/SHA224withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00800_PARAMS, sizeof(DSA_00800_PARAMS) / sizeof(DSA_00800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslDsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); + + uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t dsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; + EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA224), 0); + + free(publicKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_00900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest00900 + * @tc.name : HksDsaMtTest00900 + * @tc.desc : Test huks Verify (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest00900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_00900_PARAMS, sizeof(DSA_00900_PARAMS) / sizeof(DSA_00900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01000 + * @tc.name : HksDsaMtTest01000 + * @tc.desc : Test huks Verify (1024/SHA224withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01000_PARAMS, sizeof(DSA_01000_PARAMS) / sizeof(DSA_01000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslDsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + DsaGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA224), 0); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); +#else + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +#endif + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslDsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01100 + * @tc.name : HksDsaMtTest01100 + * @tc.desc : Test huks generate key (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01100_PARAMS, sizeof(DSA_01100_PARAMS) / sizeof(DSA_01100_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA256), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01200 + * @tc.name : HksDsaMtTest01200 + * @tc.desc : Test huks sign (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01200, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01200_PARAMS, sizeof(DSA_01200_PARAMS) / sizeof(DSA_01200_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA256), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01300 + * @tc.name : HksDsaMtTest01300 + * @tc.desc : Test huks sign (1024/SHA256withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01300_PARAMS, sizeof(DSA_01300_PARAMS) / sizeof(DSA_01300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslDsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); + + uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t dsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; + EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA256), 0); + + free(publicKey.data); + free(signData.data); + +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01400 + * @tc.name : HksDsaMtTest01400 + * @tc.desc : Test huks Verify (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01400, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01400_PARAMS, sizeof(DSA_01400_PARAMS) / sizeof(DSA_01400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01500 + * @tc.name : HksDsaMtTest01500 + * @tc.desc : Test huks Verify (1024/SHA256withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01500_PARAMS, sizeof(DSA_01500_PARAMS) / sizeof(DSA_01500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslDsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + DsaGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA256), 0); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); +#else + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +#endif + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslDsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01600 + * @tc.name : HksDsaMtTest01600 + * @tc.desc : Test huks generate key (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01600, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01600_PARAMS, sizeof(DSA_01600_PARAMS) / sizeof(DSA_01600_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA384), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01700 + * @tc.name : HksDsaMtTest01700 + * @tc.desc : Test huks sign (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01700_PARAMS, sizeof(DSA_01700_PARAMS) / sizeof(DSA_01700_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA384), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01800 + * @tc.name : HksDsaMtTest01800 + * @tc.desc : Test huks sign (1024/SHA384withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01800_PARAMS, sizeof(DSA_01800_PARAMS) / sizeof(DSA_01800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslDsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); + + uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t dsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; + EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA384), 0); + + free(publicKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_01900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest01900 + * @tc.name : HksDsaMtTest01900 + * @tc.desc : Test huks Verify (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest01900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_01900_PARAMS, sizeof(DSA_01900_PARAMS) / sizeof(DSA_01900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_02000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest02000 + * @tc.name : HksDsaMtTest02000 + * @tc.desc : Test huks Verify (1024/SHA384withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest02000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, DSA_02000_PARAMS, sizeof(DSA_02000_PARAMS) / sizeof(DSA_02000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslDsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + DsaGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA384), 0); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); +#else + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +#endif + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslDsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_02100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest02100 + * @tc.name : HksDsaMtTest02100 + * @tc.desc : Test huks generate key (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest02100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_02100_PARAMS, sizeof(DSA_02100_PARAMS) / sizeof(DSA_02100_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA512), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_02200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest02200 + * @tc.name : HksDsaMtTest02200 + * @tc.desc : Test huks sign (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest02200, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_02200_PARAMS, sizeof(DSA_02200_PARAMS) / sizeof(DSA_02200_PARAMS[0])), + HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA512), 0); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_02300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest02300 + * @tc.name : HksDsaMtTest02300 + * @tc.desc : Test huks sign (1024/SHA512withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest02300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_02300_PARAMS, sizeof(DSA_02300_PARAMS) / sizeof(DSA_02300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslDsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); + + uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t dsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; + EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA512), 0); + + free(publicKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_02400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest02400 + * @tc.name : HksDsaMtTest02400 + * @tc.desc : Test huks Verify (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest02400, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, DSA_02400_PARAMS, sizeof(DSA_02400_PARAMS) / sizeof(DSA_02400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); +#else + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(publicKey.data); + free(privateKey.data); + free(signData.data); +#endif + free(paramSetOut); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam DSA_02500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksDsaMtTest02500 + * @tc.name : HksDsaMtTest02500 + * @tc.desc : Test huks Verify (1024/SHA512withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaTestMT, HksDsaMtTest02500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, DSA_02500_PARAMS, sizeof(DSA_02500_PARAMS) / sizeof(DSA_02500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslDsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + DsaGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA512), 0); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); +#else + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +#endif + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslDsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt_test.cpp new file mode 100755 index 00000000..fe00ad37 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt_test.cpp @@ -0,0 +1,1497 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_ecc_mt_test.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char ECC_224KEY[] = "This is a ECC_224 key"; +const char ECC_256KEY[] = "This is a ECC_256 key"; +const char ECC_384KEY[] = "This is a ECC_384 key"; +const char ECC_521KEY[] = "This is a ECC_521 key"; +} // namespace +class HksEccKeyMtTest : public testing::Test {}; + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00100 + * @tc.name : HksEccKeyMtTest00100 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00200 + * @tc.name : HksEccKeyMtTest00200 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00300 + * @tc.name : HksEccKeyMtTest00300 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00400 + * @tc.name : HksEccKeyMtTest00400 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00500 + * @tc.name : HksEccKeyMtTest00500 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00600 + * @tc.name : HksEccKeyMtTest00600 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00700 + * @tc.name : HksEccKeyMtTest00700 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00800 + * @tc.name : HksEccKeyMtTest00800 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00900 + * @tc.name : HksEccKeyMtTest00900 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01000 + * @tc.name : HksEccKeyMtTest01000 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01100 + * @tc.name : HksEccKeyMtTest01100 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01200 + * @tc.name : HksEccKeyMtTest01200 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01300 + * @tc.name : HksEccKeyMtTest01300 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01400 + * @tc.name : HksEccKeyMtTest01400 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01500 + * @tc.name : HksEccKeyMtTest01500 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01600 + * @tc.name : HksEccKeyMtTest01600 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01700 + * @tc.name : HksEccKeyMtTest01700 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01800 + * @tc.name : HksEccKeyMtTest01800 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01900 + * @tc.name : HksEccKeyMtTest01900 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02000 + * @tc.name : HksEccKeyMtTest02000 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02100 + * @tc.name : HksEccKeyMtTest02100 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02200 + * @tc.name : HksEccKeyMtTest02200 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02300 + * @tc.name : HksEccKeyMtTest02300 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02400 + * @tc.name : HksEccKeyMtTest02400 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + free(priKey.data); + free(pubKey.data); + free(signature.data); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt_test.cpp new file mode 100755 index 00000000..f6ad1b4a --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt_test.cpp @@ -0,0 +1,2217 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_ecc_mt_test.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char ECC_224KEY[] = "This is a ECC_224 key"; +const char ECC_256KEY[] = "This is a ECC_256 key"; +const char ECC_384KEY[] = "This is a ECC_384 key"; +const char ECC_521KEY[] = "This is a ECC_521 key"; +} // namespace +class HksEccSignMtTest : public testing::Test {}; + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00100 + * @tc.name : HksEccSignMtTest00100 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00200 + * @tc.name : HksEccSignMtTest00200 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00300 + * @tc.name : HksEccSignMtTest00300 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00400 + * @tc.name : HksEccSignMtTest00400 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00500 + * @tc.name : HksEccSignMtTest00500 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00600 + * @tc.name : HksEccSignMtTest00600 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00700 + * @tc.name : HksEccSignMtTest00700 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00800 + * @tc.name : HksEccSignMtTest00800 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest00900 + * @tc.name : HksEccSignMtTest00900 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01000 + * @tc.name : HksEccSignMtTest01000 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01100 + * @tc.name : HksEccSignMtTest01100 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01200 + * @tc.name : HksEccSignMtTest01200 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01300 + * @tc.name : HksEccSignMtTest01300 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01400 + * @tc.name : HksEccSignMtTest01400 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01500 + * @tc.name : HksEccSignMtTest01500 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01600 + * @tc.name : HksEccSignMtTest01600 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01700 + * @tc.name : HksEccSignMtTest01700 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01800 + * @tc.name : HksEccSignMtTest01800 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest01900 + * @tc.name : HksEccSignMtTest01900 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02000 + * @tc.name : HksEccSignMtTest02000 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02100 + * @tc.name : HksEccSignMtTest02100 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02200 + * @tc.name : HksEccSignMtTest02200 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02300 + * @tc.name : HksEccSignMtTest02300 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02400 + * @tc.name : HksEccSignMtTest02400 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02500 + * @tc.name : HksEccSignMtTest02500 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02600 + * @tc.name : HksEccSignMtTest02600 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02700 + * @tc.name : HksEccSignMtTest02700 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02800 + * @tc.name : HksEccSignMtTest02800 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest02900 + * @tc.name : HksEccSignMtTest02900 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03000 + * @tc.name : HksEccSignMtTest03000 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03100 + * @tc.name : HksEccSignMtTest03100 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03200 + * @tc.name : HksEccSignMtTest03200 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03300 + * @tc.name : HksEccSignMtTest03300 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03400 + * @tc.name : HksEccSignMtTest03400 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03500 + * @tc.name : HksEccSignMtTest03500 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03600 + * @tc.name : HksEccSignMtTest03600 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03700 + * @tc.name : HksEccSignMtTest03700 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03800 + * @tc.name : HksEccSignMtTest03800 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest03900 + * @tc.name : HksEccSignMtTest03900 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04000 + * @tc.name : HksEccSignMtTest04000 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04100 + * @tc.name : HksEccSignMtTest04100 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04200 + * @tc.name : HksEccSignMtTest04200 + * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04300 + * @tc.name : HksEccSignMtTest04300 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04400 + * @tc.name : HksEccSignMtTest04400 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04500 + * @tc.name : HksEccSignMtTest04500 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04600 + * @tc.name : HksEccSignMtTest04600 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04700 + * @tc.name : HksEccSignMtTest04700 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} + +/** + * @tc.number : HksEccSignMtTest.HksEccSignMtTest04800 + * @tc.name : HksEccSignMtTest04800 + * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(x509Key.data); + free(pubKey.data); + free(signature.data); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt_test.cpp new file mode 100755 index 00000000..cf2e3858 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt_test.cpp @@ -0,0 +1,2194 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_ecc_mt_test.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char ECC_224KEY[] = "This is a ECC_224 key"; +const char ECC_256KEY[] = "This is a ECC_256 key"; +const char ECC_384KEY[] = "This is a ECC_384 key"; +const char ECC_521KEY[] = "This is a ECC_521 key"; +const char PUB_KEY[] = "This is a public key"; +} // namespace +class HksEccVerifyMtTest : public testing::Test {}; + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00100 + * @tc.name : HksEccVerifyMtTest00100 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00200 + * @tc.name : HksEccVerifyMtTest00200 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00300 + * @tc.name : HksEccVerifyMtTest00300 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00400 + * @tc.name : HksEccVerifyMtTest00400 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00500 + * @tc.name : HksEccVerifyMtTest00500 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00600 + * @tc.name : HksEccVerifyMtTest00600 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00700 + * @tc.name : HksEccVerifyMtTest00700 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00800 + * @tc.name : HksEccVerifyMtTest00800 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00900 + * @tc.name : HksEccVerifyMtTest00900 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01000 + * @tc.name : HksEccVerifyMtTest01000 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01100 + * @tc.name : HksEccVerifyMtTest01100 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01200 + * @tc.name : HksEccVerifyMtTest01200 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01300 + * @tc.name : HksEccVerifyMtTest01300 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01400 + * @tc.name : HksEccVerifyMtTest01400 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01500 + * @tc.name : HksEccVerifyMtTest01500 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01600 + * @tc.name : HksEccVerifyMtTest01600 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01700 + * @tc.name : HksEccVerifyMtTest01700 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01800 + * @tc.name : HksEccVerifyMtTest01800 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01900 + * @tc.name : HksEccVerifyMtTest01900 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02000 + * @tc.name : HksEccVerifyMtTest02000 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02100 + * @tc.name : HksEccVerifyMtTest02100 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02200 + * @tc.name : HksEccVerifyMtTest02200 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02300 + * @tc.name : HksEccVerifyMtTest02300 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02400 + * @tc.name : HksEccVerifyMtTest02400 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02500 + * @tc.name : HksEccVerifyMtTest02500 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02600 + * @tc.name : HksEccVerifyMtTest02600 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02700 + * @tc.name : HksEccVerifyMtTest02700 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02800 + * @tc.name : HksEccVerifyMtTest02800 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02900 + * @tc.name : HksEccVerifyMtTest02900 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03000 + * @tc.name : HksEccVerifyMtTest03000 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03100 + * @tc.name : HksEccVerifyMtTest03100 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03200 + * @tc.name : HksEccVerifyMtTest03200 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03300 + * @tc.name : HksEccVerifyMtTest03300 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03400 + * @tc.name : HksEccVerifyMtTest03400 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03500 + * @tc.name : HksEccVerifyMtTest03500 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03600 + * @tc.name : HksEccVerifyMtTest03600 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03700 + * @tc.name : HksEccVerifyMtTest03700 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03800 + * @tc.name : HksEccVerifyMtTest03800 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03900 + * @tc.name : HksEccVerifyMtTest03900 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03900, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04000 + * @tc.name : HksEccVerifyMtTest04000 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04100 + * @tc.name : HksEccVerifyMtTest04100 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04100, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04200 + * @tc.name : HksEccVerifyMtTest04200 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04300 + * @tc.name : HksEccVerifyMtTest04300 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04300, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04400 + * @tc.name : HksEccVerifyMtTest04400 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04500 + * @tc.name : HksEccVerifyMtTest04500 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04500, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04600 + * @tc.name : HksEccVerifyMtTest04600 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04700 + * @tc.name : HksEccVerifyMtTest04700 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04700, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} + +/** + * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04800 + * @tc.name : HksEccVerifyMtTest04800 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(pubKey.data); + free(x509Key.data); + free(signature.data); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp new file mode 100755 index 00000000..e365eb65 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp @@ -0,0 +1,740 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_hmac_mt_test.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char HMAC_KEY[] = "This is a HMAC key"; +} // namespace +class HksHmacMtTest : public testing::Test {}; + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00100 + * @tc.name : HksHmacMtTest00100 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00100, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { + .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + + HksParam *outParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); + + HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; + (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); + + EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA1, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + free(localKey.blob.data); + free(macMessage.data); + free(macForHuks.data); + free(key.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00200 + * @tc.name : HksHmacMtTest00200 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00200, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { + .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + + HksParam *outParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); + + HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; + (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); + + EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA224, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + free(localKey.blob.data); + free(macMessage.data); + free(macForHuks.data); + free(key.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00300 + * @tc.name : HksHmacMtTest00300 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00300, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { + .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + + HksParam *outParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); + + HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; + (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); + + EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA256, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + free(localKey.blob.data); + free(macMessage.data); + free(macForHuks.data); + free(key.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00400 + * @tc.name : HksHmacMtTest00400 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00400, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { + .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + + HksParam *outParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); + + HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; + (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); + + EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA384, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + free(localKey.blob.data); + free(macMessage.data); + free(macForHuks.data); + free(key.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00500 + * @tc.name : HksHmacMtTest00500 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00500, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { + .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); + + HksParam *outParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); + + HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; + (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); + + EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA512, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + free(localKey.blob.data); + free(macMessage.data); + free(macForHuks.data); + free(key.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00600 + * @tc.name : HksHmacMtTest00600 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00600, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); + + EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA1, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macMessage.data); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00700 + * @tc.name : HksHmacMtTest00700 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00700, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); + + EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA224, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macMessage.data); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00800 + * @tc.name : HksHmacMtTest00800 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00800, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); + + EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA256, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macMessage.data); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest00900 + * @tc.name : HksHmacMtTest00900 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest00900, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); + + EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA384, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macMessage.data); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest01000 + * @tc.name : HksHmacMtTest01000 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest01000, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); + + EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA512, &message, &macMessage), HMAC_SUCCESS); + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macMessage.data); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest01100 + * @tc.name : HksHmacMtTest01100 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest01100, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest01200 + * @tc.name : HksHmacMtTest01200 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest01200, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest01300 + * @tc.name : HksHmacMtTest01300 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest01300, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest01400 + * @tc.name : HksHmacMtTest01400 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest01400, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macForHuks.data); +} + +/** + * @tc.number : HksHmacMtTest.HksHmacMtTest01500 + * @tc.name : HksHmacMtTest01500 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMtTest, HksHmacMtTest01500, TestSize.Level1) +{ + struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, + {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, + {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, + {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, + {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, + {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, + {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; + HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + free(macForHuks.data); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_aes_test_mt.c b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_aes_test_mt.c index 29abaf39..509917c2 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_aes_test_mt.c +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_aes_test_mt.c @@ -15,16 +15,7 @@ #include "hks_openssl_aes_test_mt.h" -#include - -#include #include -#include - -#include "hks_crypto_hal.h" -#include "hks_log.h" -#include "hks_param.h" -#include "hks_type.h" #define BIT_NUM_OF_UINT8 8 #define HKS_AE_TAG_LEN 16 diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dh_mt_test.c b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dh_mt_test.c new file mode 100755 index 00000000..52e921e4 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dh_mt_test.c @@ -0,0 +1,259 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_dh_mt_test.h" + +#include +#include +#include + +#include "hks_crypto_hal.h" +#include "hks_mem.h" + +static int32_t DhGetNid(uint32_t keySize, int *nid) +{ + switch (keySize) { + case HKS_DH_KEY_SIZE_2048: + *nid = NID_ffdhe2048; + return DH_SUCCESS; + case HKS_DH_KEY_SIZE_3072: + *nid = NID_ffdhe3072; + return DH_SUCCESS; + case HKS_DH_KEY_SIZE_4096: + *nid = NID_ffdhe4096; + return DH_SUCCESS; + default: + return DH_FAILED; + } +} + +static int32_t DhSaveKeyMaterial(const DH *dh, const uint32_t keySize, struct HksBlob *key) +{ + const BIGNUM *pubKey = NULL; + const BIGNUM *privKey = NULL; + DH_get0_key(dh, &pubKey, &privKey); + const uint32_t rawMaterialLen = sizeof(struct KeyMaterialDh) + BN_num_bytes(pubKey) + BN_num_bytes(privKey); + uint8_t *rawMaterial = (uint8_t *)malloc(rawMaterialLen); + if (rawMaterial == NULL) { + return DH_FAILED; + } + + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = keySize; + keyMaterial->pubKeySize = BN_num_bytes(pubKey); + keyMaterial->priKeySize = BN_num_bytes(privKey); + keyMaterial->reserved = 0; + + uint32_t offset = sizeof(struct KeyMaterialDh); + BN_bn2bin(pubKey, rawMaterial + offset); + offset += keyMaterial->pubKeySize; + BN_bn2bin(privKey, rawMaterial + offset); + offset += keyMaterial->priKeySize; + + key->size = rawMaterialLen; + key->data = rawMaterial; + + return DH_SUCCESS; +} + +int32_t DhGenerateKey(const int keyLen, struct HksBlob *key) +{ + int32_t ret; + int nid = 0; + ret = DhGetNid(keyLen, &nid); + if (ret != DH_SUCCESS) { + return ret; + } + + DH *dh = DH_new_by_nid(nid); + if (dh == NULL) { + return DH_FAILED; + } + if (DH_generate_key(dh) != 1) { + DH_free(dh); + return DH_FAILED; + } + + ret = DhSaveKeyMaterial(dh, keyLen, key); + + DH_free(dh); + + return ret; +} + +static DH *InitDhStruct(const struct HksBlob *key, const bool needPrivateExponent) +{ + int32_t ret = DH_SUCCESS; + const struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)(key->data); + if (key->size != sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize + keyMaterial->priKeySize) { + return NULL; + } + + int nid = 0; + ret = DhGetNid(keyMaterial->keySize, &nid); + if (ret != DH_SUCCESS) { + return NULL; + } + + DH *dh = DH_new_by_nid(nid); + if (dh == NULL) { + return NULL; + } + + uint32_t offset = sizeof(struct KeyMaterialDh); + BIGNUM *pubKey = BN_bin2bn(key->data + offset, keyMaterial->pubKeySize, NULL); + offset += keyMaterial->pubKeySize; + BIGNUM *privKey = BN_bin2bn(key->data + offset, keyMaterial->priKeySize, NULL); + + if (DH_set0_key(dh, pubKey, privKey) != 1) { + DH_free(dh); + return NULL; + } + + return dh; +} + +int32_t DhAgreeKey( + const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey) +{ + int32_t ret; + if ((uint32_t)HKS_KEY_BYTES(keyLen) > sharedKey->size) { + return DH_FAILED; + } + + struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data; + BIGNUM *pub = BN_bin2bn(pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL); + if (pub == NULL) { + return DH_FAILED; + } + + DH *dh = InitDhStruct(nativeKey, true); + if (dh == NULL) { + BN_free(pub); + return DH_FAILED; + } + + uint8_t computeKey[DH_size(dh)]; + + if (DH_compute_key_padded(computeKey, pub, dh) <= 0) { + BN_free(pub); + DH_free(dh); + return DH_FAILED; + } + + if (HKS_KEY_BYTES(keyLen) > DH_size(dh)) { + ret = DH_FAILED; + } else { + (void)memcpy_s(sharedKey->data, sharedKey->size, computeKey, HKS_KEY_BYTES(keyLen)); + sharedKey->size = DH_size(dh); + ret = DH_SUCCESS; + } + + BN_free(pub); + DH_free(dh); + return ret; +} + +int32_t DhGetDhPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)input->data; + if (input->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return DH_FAILED; + } + if (output->size < sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize) { + return DH_FAILED; + } + + (void)memcpy_s(output->data, output->size, input->data, sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize); + ((struct KeyMaterialDh *)output->data)->priKeySize = 0; + ((struct KeyMaterialDh *)output->data)->reserved = 0; + output->size = sizeof(struct KeyMaterialDh) + keyMaterial->pubKeySize; + + return DH_SUCCESS; +} + +int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey) +{ + if (x509Key == NULL || x509Key->data == NULL || x509Key->size == 0 || publicKey == NULL) { + return DH_FAILED; + } + + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); + if (pkey == NULL) { + return DH_FAILED; + } + + DH *dh = EVP_PKEY_get0_DH(pkey); + if (dh == NULL) { + return DH_FAILED; + } + + const BIGNUM *pubKey = DH_get0_pub_key(dh); + uint32_t dhpubKeySize = BN_num_bytes(pubKey); + + uint8_t *keyBuffer = HksMalloc(sizeof(struct KeyMaterialDh) + dhpubKeySize); + if (keyBuffer == NULL) { + return DH_FAILED; + } + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)keyBuffer; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = DH_bits(dh); + keyMaterial->pubKeySize = dhpubKeySize; + keyMaterial->priKeySize = 0; + keyMaterial->reserved = 0; + + BN_bn2bin(pubKey, keyBuffer + sizeof(struct KeyMaterialDh)); + + publicKey->size = dhpubKeySize; + publicKey->data = keyBuffer; + + SELF_FREE_PTR(pkey, EVP_PKEY_free); + return DH_SUCCESS; +} + +int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key) +{ + struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)key->data; + BIGNUM *pub = BN_bin2bn(key->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL); + if (pub == NULL) { + return DH_FAILED; + } + + DH *dh = InitDhStruct(key, true); + if (dh == NULL) { + BN_free(pub); + return DH_FAILED; + } + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + DH_free(dh); + return DH_FAILED; + } + + if (EVP_PKEY_assign_DH(pkey, dh) <= 0) { + DH_free(dh); + EVP_PKEY_free(pkey); + return DH_FAILED; + } + + uint8_t *tmp = NULL; + int32_t length = i2d_PUBKEY(pkey, &tmp); + x509Key->size = length; + x509Key->data = tmp; + return DH_SUCCESS; +} \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dsa_sign_test_mt.c b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dsa_sign_test_mt.c new file mode 100755 index 00000000..5a1c2c00 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dsa_sign_test_mt.c @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_dsa_sign_test_mt.h" + +#include +#include + +#include "hks_crypto_hal.h" +#include "hks_common_check.h" + +#define OPENSSL_KEY_BLOCK 8 +#define OPENSSL_DSA_MIN_KEY_LEN 64 +#define OPENSSL_DSA_KEY_LEN_DIVID (2048 / HKS_BITS_PER_BYTE) + +EVP_PKEY *GenerateDsaKey(const uint32_t keySize) +{ + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + return NULL; + } + DSA *dsa = DSA_new(); + if (dsa == NULL) { + EVP_PKEY_free(pkey); + return NULL; + } + if (DSA_generate_parameters_ex(dsa, keySize, NULL, 0, NULL, NULL, NULL) != 1) { + EVP_PKEY_free(pkey); + DSA_free(dsa); + return NULL; + } + if (DSA_generate_key(dsa) != 1) { + EVP_PKEY_free(pkey); + DSA_free(dsa); + return NULL; + } + + EVP_PKEY_assign_DSA(pkey, dsa); + + return pkey; +} + +static DSA *InitDsa(struct HksBlob *key, const bool needPrivateExponent) +{ + const struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)(key->data); + uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)]; + + uint32_t offset = sizeof(*keyMaterial); + BIGNUM *x = NULL; + if (needPrivateExponent) { + (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->xSize); + x = BN_bin2bn(buff, keyMaterial->xSize, NULL); + } + + offset += keyMaterial->xSize; + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->ySize) != 0) { + return NULL; + } + BIGNUM *y = BN_bin2bn(buff, keyMaterial->ySize, NULL); + + offset += keyMaterial->ySize; + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->pSize) != 0) { + return NULL; + } + BIGNUM *p = BN_bin2bn(buff, keyMaterial->pSize, NULL); + + offset += keyMaterial->pSize; + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->qSize) != 0) { + return NULL; + } + BIGNUM *q = BN_bin2bn(buff, keyMaterial->qSize, NULL); + + offset += keyMaterial->qSize; + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->gSize) != 0) { + return NULL; + } + BIGNUM *g = BN_bin2bn(buff, keyMaterial->gSize, NULL); + + DSA *dsa = DSA_new(); + if (DSA_set0_key(dsa, y, x) != 1 || DSA_set0_pqg(dsa, p, q, g) != 1) { + return NULL; + } + + return dsa; +} + +static const EVP_MD *GetOpensslDigestType(enum HksKeyDigest digestType) +{ + switch (digestType) { + case HKS_DIGEST_MD5: + return EVP_md5(); + case HKS_DIGEST_SHA1: + return EVP_sha1(); + case HKS_DIGEST_SHA224: + return EVP_sha224(); + case HKS_DIGEST_SHA256: + return EVP_sha256(); + case HKS_DIGEST_SHA384: + return EVP_sha384(); + case HKS_DIGEST_SHA512: + return EVP_sha512(); + default: + return NULL; + } +} + +int32_t OpensslSignDsa( + const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, enum HksKeyDigest digestType) +{ + DSA *dsa = InitDsa(key, true); + if (dsa == NULL) { + return DSA_FAILED; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + + EVP_PKEY_assign_DSA(pkey, dsa); + EVP_MD_CTX *mctx = EVP_MD_CTX_new(); + if (mctx == NULL) { + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + const EVP_MD *md = GetOpensslDigestType(digestType); + if (EVP_DigestSignInit(mctx, NULL, md, NULL, pkey) != 1) { + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + if (EVP_DigestSignUpdate(mctx, plainText->data, plainText->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + + size_t signLen = signData->size; + if (EVP_DigestSignFinal(mctx, signData->data, &signLen) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + + signData->size = signLen; + + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + + return DSA_SUCCESS; +} + +int32_t OpensslVerifyDsa( + const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, enum HksKeyDigest digestType) +{ + DSA *dsa = InitDsa(key, false); + if (dsa == NULL) { + return DSA_FAILED; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + + EVP_PKEY_assign_DSA(pkey, dsa); + EVP_MD_CTX *mctx = EVP_MD_CTX_new(); + if (mctx == NULL) { + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + const EVP_MD *md = GetOpensslDigestType(digestType); + if (EVP_DigestVerifyInit(mctx, NULL, md, NULL, pkey) != 1) { + EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); + return DSA_FAILED; + } + + if (EVP_DigestVerifyUpdate(mctx, plainText->data, plainText->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + + if (EVP_DigestVerifyFinal(mctx, signData->data, signData->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return DSA_FAILED; + } + + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + + return DSA_SUCCESS; +} + +int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey) +{ + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&x509Key->data, x509Key->size); + if (pkey == NULL) { + return DSA_FAILED; + } + + DSA *dsa = EVP_PKEY_get1_DSA(pkey); + if (dsa == NULL) { + return DSA_FAILED; + } + int32_t ySize = BN_num_bytes(DSA_get0_pub_key(dsa)); + int32_t pSize = BN_num_bytes(DSA_get0_p(dsa)); + int32_t qSize = BN_num_bytes(DSA_get0_q(dsa)); + int32_t gSize = BN_num_bytes(DSA_get0_g(dsa)); + if ((ySize <= 0) || (pSize <= 0) || (qSize <= 0) || (gSize <= 0)) { + return DSA_FAILED; + } + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)publicKey->data; + keyMaterial->keyAlg = HKS_ALG_DSA; + keyMaterial->keySize = (ySize + HKS_BITS_PER_BYTE - 1) / HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE; + keyMaterial->xSize = 0; + keyMaterial->ySize = ySize; + keyMaterial->pSize = pSize; + keyMaterial->qSize = qSize; + keyMaterial->gSize = gSize; + + if ((BN_bn2bin(DSA_get0_pub_key(dsa), publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize) == 0) || + (BN_bn2bin(DSA_get0_p(dsa), publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize) == + 0) || + (BN_bn2bin(DSA_get0_q(dsa), + publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize) == 0) || + (BN_bn2bin(DSA_get0_g(dsa), + publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize + qSize) == 0)) { + free(publicKey->data); + return DSA_FAILED; + } + + return DSA_SUCCESS; +} + +void DsaGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key) +{ + uint8_t *tmp = NULL; + int32_t length = i2d_PUBKEY(pkey, &tmp); + x509Key->size = length; + x509Key->data = tmp; +} + +int32_t SaveDsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key) +{ + int32_t ret; + uint32_t opensslKeyByteLen = HKS_KEY_BYTES(keySize); + if (opensslKeyByteLen < OPENSSL_DSA_MIN_KEY_LEN) { + opensslKeyByteLen = OPENSSL_DSA_MIN_KEY_LEN; + } + uint32_t keyByteLen = (opensslKeyByteLen + OPENSSL_KEY_BLOCK - 1) / OPENSSL_KEY_BLOCK * OPENSSL_KEY_BLOCK; + + struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)key->data; + keyMaterial->keyAlg = HKS_ALG_DSA; + keyMaterial->keySize = keyByteLen * HKS_BITS_PER_BYTE; + keyMaterial->xSize = (keyByteLen > OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + keyMaterial->ySize = keyByteLen; + keyMaterial->pSize = keyByteLen; + keyMaterial->qSize = (keyByteLen > OPENSSL_DSA_KEY_LEN_DIVID) ? HKS_DIGEST_SHA256_LEN : HKS_DIGEST_SHA1_LEN; + keyMaterial->gSize = keyByteLen; + + const BIGNUM *x = DSA_get0_priv_key(EVP_PKEY_get0_DSA(pkey)); + const BIGNUM *y = DSA_get0_pub_key(EVP_PKEY_get0_DSA(pkey)); + const BIGNUM *p = DSA_get0_p(EVP_PKEY_get0_DSA(pkey)); + const BIGNUM *q = DSA_get0_q(EVP_PKEY_get0_DSA(pkey)); + const BIGNUM *g = DSA_get0_g(EVP_PKEY_get0_DSA(pkey)); + + int32_t offset = sizeof(struct KeyMaterialDsa); + ret = BN_bn2bin(x, key->data + offset + (keyMaterial->xSize - BN_num_bytes(x))); + if (ret <= 0) { + return DSA_FAILED; + } + offset += keyMaterial->xSize; + ret = BN_bn2bin(y, key->data + offset + (keyMaterial->ySize - BN_num_bytes(y))); + if (ret <= 0) { + return DSA_FAILED; + } + offset += keyMaterial->ySize; + ret = BN_bn2bin(p, key->data + offset + (keyMaterial->pSize - BN_num_bytes(p))); + if (ret <= 0) { + return DSA_FAILED; + } + offset += keyMaterial->pSize; + ret = BN_bn2bin(q, key->data + offset + (keyMaterial->qSize - BN_num_bytes(q))); + if (ret <= 0) { + return DSA_FAILED; + } + offset += keyMaterial->qSize; + ret = BN_bn2bin(g, key->data + offset + (keyMaterial->gSize - BN_num_bytes(g))); + if (ret <= 0) { + return DSA_FAILED; + } + return DSA_SUCCESS; +} diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_ecc_mt_test.c b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_ecc_mt_test.c new file mode 100755 index 00000000..13f138df --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_ecc_mt_test.c @@ -0,0 +1,594 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_ecc_mt_test.h" + +#include +#include +#include + +#include "hks_crypto_hal.h" +#include "hks_mem.h" + +static int32_t GetCurveId(uint32_t keyLen, int *nid) +{ + switch (keyLen) { + case HKS_ECC_KEY_SIZE_224: + *nid = NID_secp224r1; + break; + case HKS_ECC_KEY_SIZE_256: + *nid = NID_X9_62_prime256v1; + break; + case HKS_ECC_KEY_SIZE_384: + *nid = NID_secp384r1; + break; + case HKS_ECC_KEY_SIZE_521: + *nid = NID_secp521r1; + break; + default: + return ECC_FAILED; + } + + return ECC_SUCCESS; +} + +const EVP_MD *GetOpensslAlg(uint32_t alg) +{ + switch (alg) { + case HKS_DIGEST_MD5: + return EVP_md5(); + case HKS_DIGEST_SHA1: + return EVP_sha1(); + case HKS_DIGEST_SHA224: + return EVP_sha224(); + case HKS_DIGEST_SHA256: + return EVP_sha256(); + case HKS_DIGEST_SHA384: + return EVP_sha384(); + case HKS_DIGEST_SHA512: + return EVP_sha512(); + default: + return NULL; + } +} + +static int32_t TransEccKeyToKeyBlob( + const struct KeyMaterialEcc *keyMaterial, BIGNUM *pubX, BIGNUM *pubY, const BIGNUM *priv, uint8_t *rawMaterial) +{ + uint32_t offset = sizeof(struct KeyMaterialEcc); + if (BN_bn2binpad(pubX, rawMaterial + offset, keyMaterial->xSize) <= 0) { + return ECC_FAILED; + } + offset += keyMaterial->xSize; + + if (BN_bn2binpad(pubY, rawMaterial + offset, keyMaterial->ySize) <= 0) { + return ECC_FAILED; + } + offset += keyMaterial->ySize; + + if (BN_bn2binpad(priv, rawMaterial + offset, keyMaterial->zSize) <= 0) { + return ECC_FAILED; + } + return ECC_SUCCESS; +} + +static int32_t EccSaveKeyMaterial(const EC_KEY *eccKey, const uint32_t keyLen, uint8_t **output, uint32_t *outputSize) +{ + uint32_t rawMaterialLen = sizeof(struct KeyMaterialEcc) + HKS_KEY_BYTES(keyLen) * ECC_KEYPAIR_CNT; + uint8_t *rawMaterial = (uint8_t *)malloc(rawMaterialLen); + if (rawMaterial == NULL) { + return ECC_FAILED; + } + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)rawMaterial; + keyMaterial->keyAlg = HKS_ALG_ECC; + keyMaterial->keySize = keyLen; + keyMaterial->xSize = HKS_KEY_BYTES(keyLen); + keyMaterial->ySize = HKS_KEY_BYTES(keyLen); + keyMaterial->zSize = HKS_KEY_BYTES(keyLen); + BIGNUM *pubX = BN_new(); + BIGNUM *pubY = BN_new(); + + if ((pubX == NULL) || (pubY == NULL)) { + free(rawMaterial); + return ECC_FAILED; + } + + const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey); + if (ecGroup == NULL) { + return ECC_FAILED; + } + + if (EC_POINT_get_affine_coordinates_GFp(ecGroup, EC_KEY_get0_public_key(eccKey), pubX, pubY, NULL) <= 0) { + return ECC_FAILED; + } + + const BIGNUM *priv = EC_KEY_get0_private_key(eccKey); + if (priv == NULL) { + return ECC_FAILED; + } + + if (TransEccKeyToKeyBlob(keyMaterial, pubX, pubY, priv, rawMaterial) == ECC_FAILED) { + return ECC_FAILED; + } + + *output = rawMaterial; + *outputSize = rawMaterialLen; + + BN_free(pubX); + BN_free(pubY); + return ECC_SUCCESS; +} + +int32_t ECCGenerateKey(const int keyLen, struct HksBlob *key) +{ + int curveId; + if (GetCurveId(keyLen, &curveId) != ECC_SUCCESS) { + return ECC_FAILED; + } + + EC_KEY *eccKey = EC_KEY_new_by_curve_name(curveId); + if (eccKey == NULL) { + return ECC_FAILED; + } + + if (EC_KEY_generate_key(eccKey) <= 0) { + return ECC_FAILED; + } + + if (EccSaveKeyMaterial(eccKey, keyLen, &key->data, &key->size) != ECC_SUCCESS) { + return ECC_FAILED; + } + + EC_KEY_free(eccKey); + return ECC_SUCCESS; +} + +static int GetEccModules( + const uint8_t *key, uint32_t *keySize, uint32_t *publicXSize, uint32_t *publicYSize, uint32_t *privateXSize) +{ + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)key; + *keySize = keyMaterial->keySize; + *publicXSize = keyMaterial->xSize; + *publicYSize = keyMaterial->ySize; + *privateXSize = keyMaterial->zSize; + + return 0; +} + +static int32_t EccInitPublicKey(EC_KEY *eccKey, const uint8_t *keyPair, uint32_t xSize, uint32_t ySize) +{ + const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey); + if (ecGroup == NULL) { + return ECC_FAILED; + } + + int32_t ret = ECC_FAILED; + uint32_t offset = sizeof(struct KeyMaterialEcc); + EC_POINT *pub = EC_POINT_new(ecGroup); + BIGNUM *pubX = BN_bin2bn(keyPair + offset, xSize, NULL); + offset += xSize; + BIGNUM *pubY = BN_bin2bn(keyPair + offset, ySize, NULL); + do { + if ((pubX == NULL) || (pubY == NULL) || (pub == NULL)) { + break; + } + + if (EC_POINT_set_affine_coordinates_GFp(ecGroup, pub, pubX, pubY, NULL) <= 0) { + break; + } + + if (EC_KEY_set_public_key(eccKey, pub) <= 0) { + break; + } + ret = ECC_SUCCESS; + } while (0); + + if (pubX != NULL) { + BN_free(pubX); + pubX = NULL; + } + + if (pubY != NULL) { + BN_free(pubY); + pubY = NULL; + } + + if (pub != NULL) { + EC_POINT_free(pub); + pub = NULL; + } + return ret; +} + +static EC_KEY *EccInitKey(const struct HksBlob *keyBlob, bool sign) +{ + /* get ecc pubX,pubY,pri */ + uint8_t *keyPair = keyBlob->data; + uint32_t publicXSize; + uint32_t publicYSize; + uint32_t privateSize; + uint32_t keySize; + + if (GetEccModules(keyPair, &keySize, &publicXSize, &publicYSize, &privateSize) != 0) { + return NULL; + } + + int nid; + if (GetCurveId(keySize, &nid) != ECC_SUCCESS) { + return NULL; + } + + EC_KEY *eccKey = EC_KEY_new_by_curve_name(nid); + if (eccKey == NULL) { + return NULL; + } + + if (EccInitPublicKey(eccKey, keyPair, publicXSize, publicYSize) != ECC_SUCCESS) { + EC_KEY_free(eccKey); + return NULL; + } + + if (sign) { + BIGNUM *pri = BN_bin2bn(keyPair + sizeof(struct KeyMaterialEcc) + publicXSize + publicYSize, privateSize, NULL); + if (pri == NULL || EC_KEY_set_private_key(eccKey, pri) <= 0) { + BN_free(pri); + EC_KEY_free(eccKey); + return NULL; + } + BN_clear_free(pri); + } + + return eccKey; +} + +static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest, bool sign) +{ + const EVP_MD *md = GetOpensslAlg(digest); + + EC_KEY *eccKey = EccInitKey(mainKey, sign); + if (eccKey == NULL) { + return NULL; + } + + EVP_PKEY *key = EVP_PKEY_new(); + if (key == NULL) { + EC_KEY_free(eccKey); + return NULL; + } + + if (EVP_PKEY_assign_EC_KEY(key, eccKey) <= 0) { + EC_KEY_free(eccKey); + EVP_PKEY_free(key); + return NULL; + } + + EVP_MD_CTX *ctx = EVP_MD_CTX_new(); + if (ctx == NULL) { + EVP_PKEY_free(key); + return NULL; + } + + if (sign) { + int32_t ret = EVP_DigestSignInit(ctx, NULL, md, NULL, key); + EVP_PKEY_free(key); + if (ret <= 0) { + EVP_MD_CTX_free(ctx); + return NULL; + } + } else { + int ret = EVP_DigestVerifyInit(ctx, NULL, md, NULL, key); + EVP_PKEY_free(key); + if (ret <= 0) { + EVP_MD_CTX_free(ctx); + return NULL; + } + } + return ctx; +} + +int32_t EcdsaSign(const struct HksBlob *key, int digest, const struct HksBlob *message, struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitEccMdCtx(key, digest, true); + if (ctx == NULL) { + return ECC_FAILED; + } + + if (EVP_DigestSignUpdate(ctx, message->data, message->size) <= 0) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + size_t req = 0; + + if (EVP_DigestSignFinal(ctx, NULL, &req) <= 0) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + + if (EVP_DigestSignFinal(ctx, signature->data, &req) <= 0) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + signature->size = req; + + EVP_MD_CTX_free(ctx); + return ECC_SUCCESS; +} + +int32_t EcdsaVerify( + const struct HksBlob *key, int digest, const struct HksBlob *message, const struct HksBlob *signature) +{ + EVP_MD_CTX *ctx = InitEccMdCtx(key, digest, false); + if (ctx == NULL) { + return ECC_FAILED; + } + + if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) <= 0) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + + if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) <= 0) { + EVP_MD_CTX_free(ctx); + return ECC_FAILED; + } + + EVP_MD_CTX_free(ctx); + return ECC_SUCCESS; +} + +int32_t GetEccPubKey(const struct HksBlob *input, struct HksBlob *output) +{ + struct KeyMaterialEcc *keyMaterial = (struct KeyMaterialEcc *)input->data; + + output->size = sizeof(struct KeyMaterialEcc) + keyMaterial->xSize + keyMaterial->ySize; + + struct KeyMaterialEcc *publickeyMaterial = (struct KeyMaterialEcc *)output->data; + publickeyMaterial->keyAlg = keyMaterial->keyAlg; + publickeyMaterial->keySize = keyMaterial->keySize; + publickeyMaterial->xSize = keyMaterial->xSize; + publickeyMaterial->ySize = keyMaterial->ySize; + publickeyMaterial->zSize = 0; + + if (memcpy_s(output->data + sizeof(struct KeyMaterialEcc), + output->size - sizeof(struct KeyMaterialEcc), + input->data + sizeof(struct KeyMaterialEcc), + keyMaterial->xSize + keyMaterial->ySize) != 0) { + return ECC_FAILED; + } + + return ECC_SUCCESS; +} + +static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey) +{ + BIGNUM *x = BN_new(); + BIGNUM *y = BN_new(); + int32_t ret; + do { + ret = ECC_FAILED; + if (x == NULL || y == NULL) { + break; + } + + if (EC_POINT_get_affine_coordinates_GFp(EC_KEY_get0_group(ecKey), EC_KEY_get0_public_key(ecKey), x, y, NULL) == + 0) { + break; + } + + int32_t xSize = BN_num_bytes(x); + int32_t ySize = BN_num_bytes(y); + if (xSize <= 0 || ySize <= 0) { + break; + } + + /* x and y in ECC algorithm is small, will never overflow. */ + uint32_t totalSize = xSize + ySize + sizeof(struct HksPubKeyInfo); + uint8_t *keyBuffer = HksMalloc(totalSize); + if (keyBuffer == NULL) { + break; + } + + struct HksPubKeyInfo *pubKeyInfo = (struct HksPubKeyInfo *)keyBuffer; + pubKeyInfo->keyAlg = HKS_ALG_ECC; + pubKeyInfo->keySize = EC_GROUP_order_bits(EC_KEY_get0_group(ecKey)); + pubKeyInfo->nOrXSize = xSize; + pubKeyInfo->eOrYSize = ySize; + if (BN_bn2bin(x, keyBuffer + sizeof(struct HksPubKeyInfo)) == 0 || + BN_bn2bin(y, keyBuffer + sizeof(struct HksPubKeyInfo) + xSize) == 0) { + HKS_FREE_PTR(keyBuffer); + break; + } + + ret = ECC_SUCCESS; + eccPublicKey->data = keyBuffer; + eccPublicKey->size = totalSize; + } while (0); + + SELF_FREE_PTR(x, BN_free); + SELF_FREE_PTR(y, BN_free); + return ret; +} + +int32_t X509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey) +{ + if (x509Key == NULL || x509Key->data == NULL || x509Key->size == 0 || publicKey == NULL) { + return ECC_FAILED; + } + + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); + if (pkey == NULL) { + return ECC_FAILED; + } + + EC_KEY *ecKey = EVP_PKEY_get0_EC_KEY(pkey); + if (ecKey == NULL) { + return ECC_FAILED; + } + + if (EcKeyToPublicKey(ecKey, publicKey) != ECC_SUCCESS) { + return ECC_FAILED; + }; + + SELF_FREE_PTR(pkey, EVP_PKEY_free); + return ECC_SUCCESS; +} + +int32_t HksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key) +{ + uint8_t *keyPair = key->data; + uint32_t publicXSize; + uint32_t publicYSize; + uint32_t privateSize; + uint32_t keySize; + + if (GetEccModules(keyPair, &keySize, &publicXSize, &publicYSize, &privateSize) != 0) { + return ECC_FAILED; + } + + int nid; + if (GetCurveId(keySize, &nid) != ECC_SUCCESS) { + return ECC_FAILED; + } + + EC_KEY *eccKey = EC_KEY_new_by_curve_name(nid); + if (eccKey == NULL) { + return ECC_FAILED; + } + + if (EccInitPublicKey(eccKey, keyPair, publicXSize, publicYSize) != ECC_SUCCESS) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + + if (EVP_PKEY_assign_EC_KEY(pkey, eccKey) <= 0) { + EC_KEY_free(eccKey); + EVP_PKEY_free(pkey); + return ECC_FAILED; + } + + uint8_t *tmp = NULL; + int32_t length = i2d_PUBKEY(pkey, &tmp); + x509Key->size = length; + x509Key->data = tmp; + return ECC_SUCCESS; +} + +int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key) +{ + EC_KEY *eccKey = EccInitKey(nativeKey, true); + if (eccKey == NULL) { + return ECC_FAILED; + } + + if (EVP_PKEY_assign_EC_KEY(key, eccKey) <= 0) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + return ECC_SUCCESS; +} + +int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key) +{ + EC_KEY *eccKey = EccInitKey(pubKey, false); + if (eccKey == NULL) { + return ECC_FAILED; + } + + if (EVP_PKEY_assign_EC_KEY(key, eccKey) <= 0) { + EC_KEY_free(eccKey); + return ECC_FAILED; + } + return ECC_SUCCESS; +} + +int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedKey) +{ + if (EVP_PKEY_derive_init(ctx) != 1) { + return ECC_FAILED; + } + if (EVP_PKEY_derive_set_peer(ctx, peerKey) != 1) { + return ECC_FAILED; + } + size_t keyLen; + if (EVP_PKEY_derive(ctx, NULL, &keyLen) != 1) { + return ECC_FAILED; + } + sharedKey->size = keyLen; + + if (sharedKey->data == NULL) { + sharedKey->data = (uint8_t *)HksMalloc(keyLen); + if (sharedKey->data == NULL) { + return ECC_FAILED; + } + } + if (EVP_PKEY_derive(ctx, sharedKey->data, &keyLen) != 1) { + HksFree(sharedKey->data); + return ECC_FAILED; + } + sharedKey->size = keyLen; + + return ECC_SUCCESS; +} + +int32_t EcdhAgreeKey( + const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey) +{ + int32_t ret = ECC_FAILED; + EVP_PKEY *pKey = EVP_PKEY_new(); + EVP_PKEY *peerKey = EVP_PKEY_new(); + EVP_PKEY_CTX *ctx = NULL; + + do { + if ((peerKey == NULL) || (pKey == NULL)) { + break; + } + if (GetNativePKey(nativeKey, pKey) != ECC_SUCCESS) { + break; + } + + if (GetPeerKey(pubKey, peerKey) != ECC_SUCCESS) { + break; + } + + ctx = EVP_PKEY_CTX_new(pKey, NULL); + if (ctx == NULL) { + break; + } + + if (EcdhDerive(ctx, peerKey, sharedKey) != ECC_SUCCESS) { + break; + } + + ret = ECC_SUCCESS; + } while (0); + + EVP_PKEY_CTX_free(ctx); + if (peerKey != NULL) { + EVP_PKEY_free(peerKey); + } + if (pKey != NULL) { + EVP_PKEY_free(pKey); + } + + return ret; +} \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_hmac_mt_test.c b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_hmac_mt_test.c new file mode 100755 index 00000000..c75e739c --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_hmac_mt_test.c @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_hmac_mt_test.h" + +int32_t HmacGenerateKey(int key_len, struct HksBlob *key) +{ + uint32_t keySizeByte = key_len / BIT_NUM_OF_UINT8; + + uint8_t *tmpKey = (uint8_t *)malloc(keySizeByte); + if (tmpKey == NULL) { + return HMAC_FAILED; + } + + if (RAND_bytes(tmpKey, keySizeByte) <= 0) { + return HMAC_FAILED; + } + + key->data = tmpKey; + key->size = keySizeByte; + + return HMAC_SUCCESS; +} + +static const EVP_MD *GetAlg(uint32_t alg) +{ + switch (alg) { + case HKS_DIGEST_SHA1: + return EVP_sha1(); + case HKS_DIGEST_SHA224: + return EVP_sha224(); + case HKS_DIGEST_SHA256: + return EVP_sha256(); + case HKS_DIGEST_SHA384: + return EVP_sha384(); + case HKS_DIGEST_SHA512: + return EVP_sha512(); + default: + return NULL; + } +} + +int32_t HmacHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) +{ + const EVP_MD *getDigestAlg = GetAlg(digestAlg); + if (getDigestAlg == NULL) { + return HMAC_FAILED; + } + if (HMAC(getDigestAlg, key->data, (int32_t)key->size, msg->data, msg->size, mac->data, &mac->size) == NULL) { + return HMAC_FAILED; + } + return HMAC_SUCCESS; +} \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_rsa_test_mt.c b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_rsa_test_mt.c index f621e922..010d1afa 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_rsa_test_mt.c +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_rsa_test_mt.c @@ -15,20 +15,10 @@ #include "hks_openssl_rsa_test_mt.h" -#include - -#include "securec.h" - -#include -#include -#include #include -#include -#include #include #include "hks_crypto_hal.h" -#include "hks_type.h" void SaveRsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key) { @@ -166,6 +156,8 @@ static RSA *InitRsa(struct HksBlob *key, const bool needPrivateExponent) static const EVP_MD *GetOpensslDigestType(enum HksKeyDigest digestType) { switch (digestType) { + case HKS_DIGEST_MD5: + return EVP_md5(); case HKS_DIGEST_SHA1: return EVP_sha1(); case HKS_DIGEST_SHA224: @@ -271,3 +263,111 @@ int32_t DecryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct return RSA_SUCCESS; } + +int32_t OpensslSignRsa(const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType) +{ + RSA *rsa = InitRsa(key, true); + if (rsa == NULL) { + return RSA_FAILED; + } + + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + EVP_PKEY_assign_RSA(pkey, rsa); + EVP_MD_CTX *mctx = EVP_MD_CTX_new(); + if (mctx == NULL) { + EVP_MD_CTX_free(mctx); + return RSA_FAILED; + } + + const EVP_MD *md = GetOpensslDigestType(digestType); + if (EVP_DigestSignInit(mctx, NULL, md, NULL, pkey) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + if (padding == RSA_PKCS1_PSS_PADDING) { + if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1 && + EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_MD_CTX_pkey_ctx(mctx), EVP_MD_size(md))) { + EVP_MD_CTX_free(mctx); + return RSA_FAILED; + } + } + + if (EVP_DigestSignUpdate(mctx, plainText->data, plainText->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + size_t signLen = signData->size; + if (EVP_DigestSignFinal(mctx, signData->data, &signLen) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + signData->size = signLen; + + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + + return RSA_SUCCESS; +} + +int32_t OpensslVerifyRsa(const struct HksBlob *plainText, struct HksBlob *signData, struct HksBlob *key, int padding, + enum HksKeyDigest digestType) +{ + RSA *rsa = InitRsa(key, false); + if (rsa == NULL) { + return RSA_FAILED; + } + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + EVP_PKEY_assign_RSA(pkey, rsa); + EVP_MD_CTX *mctx = EVP_MD_CTX_new(); + if (mctx == NULL) { + EVP_MD_CTX_free(mctx); + return RSA_FAILED; + } + + const EVP_MD *md = GetOpensslDigestType(digestType); + if (EVP_DigestVerifyInit(mctx, NULL, md, NULL, pkey) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + if (padding == RSA_PKCS1_PSS_PADDING) { + if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1 && + EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_MD_CTX_pkey_ctx(mctx), EVP_MD_size(md))) { + EVP_MD_CTX_free(mctx); + return RSA_FAILED; + } + } + + if (EVP_DigestVerifyUpdate(mctx, plainText->data, plainText->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + if (EVP_DigestVerifyFinal(mctx, signData->data, signData->size) != 1) { + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } + + EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); + + return RSA_SUCCESS; +} \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp index 8f094533..a2e27e9d 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp @@ -13,14 +13,12 @@ * limitations under the License. */ +#include "hks_openssl_rsa_test_mt.h" + #include #include "hks_api.h" #include "hks_mem.h" -#include "hks_openssl_rsa_test_mt.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" using namespace testing::ext; namespace { @@ -32,20 +30,26 @@ const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; +const char HEXDATA_4096[] = + "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" + "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" + "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" + "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" + "012345678901234567890123456789012345678901234567890123456789012345678901"; } // namespace class HksRsaEcbNopaddingMt : public testing::Test {}; static const struct HksParam RSA_00100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -71,29 +75,29 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -108,15 +112,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00100, TestSize.Level1) } static const struct HksParam RSA_00200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -144,30 +148,30 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00200, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -182,15 +186,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00200, TestSize.Level1) } static const struct HksParam RSA_00300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** * @tc.number : HksRsaMtTest00300 @@ -218,31 +222,31 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" "234567890123456789012345678901234567"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -257,15 +261,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00300, TestSize.Level1) } static const struct HksParam RSA_00400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -294,14 +298,14 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00400, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); @@ -309,17 +313,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00400, TestSize.Level1) "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" "456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -334,15 +338,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00400, TestSize.Level1) } static const struct HksParam RSA_00500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -371,14 +375,14 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); @@ -388,17 +392,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00500, TestSize.Level1) "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -413,15 +417,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00500, TestSize.Level1) } static const struct HksParam RSA_00600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -450,14 +454,14 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00600, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); @@ -468,17 +472,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00600, TestSize.Level1) "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789012345678901"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -493,15 +497,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00600, TestSize.Level1) } static const struct HksParam RSA_00700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -530,35 +534,40 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -569,15 +578,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00700, TestSize.Level1) } static const struct HksParam RSA_00800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -587,7 +596,7 @@ static const struct HksParam RSA_00800_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -600,21 +609,21 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00800, TestSize.Level1) const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); ASSERT_NE(pkey, nullptr); @@ -625,12 +634,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00800, TestSize.Level1) SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ( DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif EVP_PKEY_free(pkey); free(decryptedText.data); @@ -640,15 +654,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00800, TestSize.Level1) } static const struct HksParam RSA_00900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -677,36 +691,41 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -717,15 +736,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00900, TestSize.Level1) } static const struct HksParam RSA_01000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -735,7 +754,7 @@ static const struct HksParam RSA_01000_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -749,21 +768,21 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01000, TestSize.Level1) const char *hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); ASSERT_NE(pkey, nullptr); @@ -774,12 +793,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01000, TestSize.Level1) SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ( DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif EVP_PKEY_free(pkey); free(decryptedText.data); @@ -789,15 +813,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01000, TestSize.Level1) } static const struct HksParam RSA_01100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -826,36 +850,41 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" "234567890123456789012345678901234567"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -866,15 +895,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01100, TestSize.Level1) } static const struct HksParam RSA_01200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -884,7 +913,7 @@ static const struct HksParam RSA_01200_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -898,21 +927,21 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01200, TestSize.Level1) const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" "234567890123456789012345678901234567"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); ASSERT_NE(pkey, nullptr); @@ -923,12 +952,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01200, TestSize.Level1) SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ( DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif EVP_PKEY_free(pkey); free(decryptedText.data); @@ -938,15 +972,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01200, TestSize.Level1) } static const struct HksParam RSA_01300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -975,14 +1009,14 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); @@ -990,22 +1024,27 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01300, TestSize.Level1) "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" "456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1016,15 +1055,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01300, TestSize.Level1) } static const struct HksParam RSA_01400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1034,7 +1073,7 @@ static const struct HksParam RSA_01400_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1049,21 +1088,21 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01400, TestSize.Level1) "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" "456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); ASSERT_NE(pkey, nullptr); @@ -1074,12 +1113,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01400, TestSize.Level1) SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ( DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), RSA_SUCCESS); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif EVP_PKEY_free(pkey); free(decryptedText.data); @@ -1089,15 +1133,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01400, TestSize.Level1) } static const struct HksParam RSA_01500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1126,14 +1170,14 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); @@ -1143,22 +1187,27 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01500, TestSize.Level1) "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1169,15 +1218,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01500, TestSize.Level1) } static const struct HksParam RSA_01600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1187,7 +1236,7 @@ static const struct HksParam RSA_01600_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1204,21 +1253,21 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01600, TestSize.Level1) "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); ASSERT_NE(pkey, nullptr); @@ -1229,12 +1278,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01600, TestSize.Level1) SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ( DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif EVP_PKEY_free(pkey); free(decryptedText.data); @@ -1244,15 +1298,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01600, TestSize.Level1) } static const struct HksParam RSA_01700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1281,40 +1335,38 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123456789012345678901"; - - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(HEXDATA_4096), .data = (uint8_t *)HEXDATA_4096 }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1325,15 +1377,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01700, TestSize.Level1) } static const struct HksParam RSA_01800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1343,7 +1395,7 @@ static const struct HksParam RSA_01800_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1361,21 +1413,21 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01800, TestSize.Level1) "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789012345678901"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); ASSERT_NE(pkey, nullptr); @@ -1386,12 +1438,17 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01800, TestSize.Level1) SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); EXPECT_EQ( DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +#endif EVP_PKEY_free(pkey); free(decryptedText.data); @@ -1401,15 +1458,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01800, TestSize.Level1) } static const struct HksParam RSA_01900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1439,34 +1496,39 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; - ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1477,15 +1539,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01900, TestSize.Level1) } static const struct HksParam RSA_02000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1495,7 +1557,7 @@ static const struct HksParam RSA_02000_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1511,30 +1573,39 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); + +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1544,15 +1615,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02000, TestSize.Level1) } static const struct HksParam RSA_02100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1581,35 +1652,42 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; - ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1620,15 +1698,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02100, TestSize.Level1) } static const struct HksParam RSA_02200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1638,7 +1716,7 @@ static const struct HksParam RSA_02200_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1654,31 +1732,40 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02200, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); + +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1688,15 +1775,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02200, TestSize.Level1) } static const struct HksParam RSA_02300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1725,35 +1812,41 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" "234567890123456789012345678901234567"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; - ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1764,15 +1857,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02300, TestSize.Level1) } static const struct HksParam RSA_02400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1782,7 +1875,7 @@ static const struct HksParam RSA_02400_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1798,31 +1891,40 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02400, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" "234567890123456789012345678901234567"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); + +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1832,15 +1934,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02400, TestSize.Level1) } static const struct HksParam RSA_02500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1869,14 +1971,14 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); @@ -1884,21 +1986,28 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02500, TestSize.Level1) "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" "456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; - ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1909,15 +2018,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02500, TestSize.Level1) } static const struct HksParam RSA_02600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1927,7 +2036,7 @@ static const struct HksParam RSA_02600_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1943,32 +2052,41 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02600, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" "456789012345678901234567890123456789012345678901234567890123456789012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); + +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -1978,15 +2096,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02600, TestSize.Level1) } static const struct HksParam RSA_02700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2015,14 +2133,14 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); @@ -2032,21 +2150,28 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02700, TestSize.Level1) "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; - ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -2057,15 +2182,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02700, TestSize.Level1) } static const struct HksParam RSA_02800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2075,7 +2200,7 @@ static const struct HksParam RSA_02800_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2091,14 +2216,14 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02800, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = @@ -2107,18 +2232,27 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02800, TestSize.Level1) "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); + +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -2128,15 +2262,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02800, TestSize.Level1) } static const struct HksParam RSA_02900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2165,39 +2299,39 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123456789012345678901"; - - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(HEXDATA_4096), .data = (uint8_t *)HEXDATA_4096 }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; - ASSERT_NE(decryptedText.data, nullptr); +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); @@ -2208,15 +2342,15 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02900, TestSize.Level1) } static const struct HksParam RSA_03000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2226,7 +2360,7 @@ static const struct HksParam RSA_03000_PARAMS[] = { */ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest03000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2242,35 +2376,36 @@ HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest03000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123456789012345678901"; - - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(HEXDATA_4096), .data = (uint8_t *)HEXDATA_4096 }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); + +#if defined(_USE_OPENSSL_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +#endif +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); +#endif free(paramSetOut); free(publicKey.data); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp index 6a473c32..be59a5ea 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp @@ -13,14 +13,12 @@ * limitations under the License. */ +#include "hks_openssl_rsa_test_mt.h" + #include #include "hks_api.h" #include "hks_mem.h" -#include "hks_openssl_rsa_test_mt.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" using namespace testing::ext; namespace { @@ -37,15 +35,15 @@ const int KEY_SIZE_3072 = 3072; class HksRsaEcbOaepPaddingMt : public testing::Test {}; static const struct HksParam RSA_03100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -71,29 +69,29 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -108,15 +106,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03100, TestSize.Level1) } static const struct HksParam RSA_03200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -144,29 +142,29 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03200, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -181,15 +179,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03200, TestSize.Level1) } static const struct HksParam RSA_03300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -218,30 +216,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -256,15 +254,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03300, TestSize.Level1) } static const struct HksParam RSA_03400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** * @tc.number : HksRsaMtTest03400 @@ -292,30 +290,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03400, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -330,15 +328,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03400, TestSize.Level1) } static const struct HksParam RSA_03500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -367,30 +365,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -405,15 +403,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03500, TestSize.Level1) } static const struct HksParam RSA_03600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -442,30 +440,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03600, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -480,15 +478,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03600, TestSize.Level1) } static const struct HksParam RSA_03700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -517,30 +515,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -556,15 +554,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03700, TestSize.Level1) } static const struct HksParam RSA_03800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -574,7 +572,7 @@ static const struct HksParam RSA_03800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -587,21 +585,21 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03800, TestSize.Level1) const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); ASSERT_NE(pkey, nullptr); @@ -626,15 +624,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03800, TestSize.Level1) } static const struct HksParam RSA_03900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -663,30 +661,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -702,15 +700,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03900, TestSize.Level1) } static const struct HksParam RSA_04000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -720,7 +718,7 @@ static const struct HksParam RSA_04000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -733,21 +731,21 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04000, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); ASSERT_NE(pkey, nullptr); @@ -772,15 +770,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04000, TestSize.Level1) } static const struct HksParam RSA_04100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -809,30 +807,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -848,15 +846,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04100, TestSize.Level1) } static const struct HksParam RSA_04200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -866,7 +864,7 @@ static const struct HksParam RSA_04200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -879,21 +877,21 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04200, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); ASSERT_NE(pkey, nullptr); @@ -918,15 +916,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04200, TestSize.Level1) } static const struct HksParam RSA_04300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -955,30 +953,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -994,15 +992,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04300, TestSize.Level1) } static const struct HksParam RSA_04400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1012,7 +1010,7 @@ static const struct HksParam RSA_04400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1025,21 +1023,21 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04400, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); ASSERT_NE(pkey, nullptr); @@ -1064,15 +1062,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04400, TestSize.Level1) } static const struct HksParam RSA_04500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1101,30 +1099,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -1140,15 +1138,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04500, TestSize.Level1) } static const struct HksParam RSA_04600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1158,7 +1156,7 @@ static const struct HksParam RSA_04600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1171,21 +1169,21 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04600, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); ASSERT_NE(pkey, nullptr); @@ -1210,15 +1208,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04600, TestSize.Level1) } static const struct HksParam RSA_04700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1247,30 +1245,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -1286,15 +1284,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04700, TestSize.Level1) } static const struct HksParam RSA_04800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1304,7 +1302,7 @@ static const struct HksParam RSA_04800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1317,21 +1315,21 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04800, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); ASSERT_NE(pkey, nullptr); @@ -1356,15 +1354,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04800, TestSize.Level1) } static const struct HksParam RSA_04900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1394,30 +1392,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1432,15 +1430,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04900, TestSize.Level1) } static const struct HksParam RSA_05000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1450,7 +1448,7 @@ static const struct HksParam RSA_05000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1466,26 +1464,26 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1499,15 +1497,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05000, TestSize.Level1) } static const struct HksParam RSA_05100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1536,30 +1534,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1574,15 +1572,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05100, TestSize.Level1) } static const struct HksParam RSA_05200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1592,7 +1590,7 @@ static const struct HksParam RSA_05200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1608,26 +1606,26 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05200, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1641,15 +1639,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05200, TestSize.Level1) } static const struct HksParam RSA_05300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1678,30 +1676,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1716,15 +1714,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05300, TestSize.Level1) } static const struct HksParam RSA_05400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1734,7 +1732,7 @@ static const struct HksParam RSA_05400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1750,26 +1748,26 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05400, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1783,15 +1781,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05400, TestSize.Level1) } static const struct HksParam RSA_05500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1820,30 +1818,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1858,15 +1856,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05500, TestSize.Level1) } static const struct HksParam RSA_05600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1876,7 +1874,7 @@ static const struct HksParam RSA_05600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1892,26 +1890,26 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05600, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1925,15 +1923,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05600, TestSize.Level1) } static const struct HksParam RSA_05700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1962,30 +1960,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2000,15 +1998,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05700, TestSize.Level1) } static const struct HksParam RSA_05800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2018,7 +2016,7 @@ static const struct HksParam RSA_05800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2034,26 +2032,26 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05800, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2067,15 +2065,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05800, TestSize.Level1) } static const struct HksParam RSA_05900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2104,30 +2102,30 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2142,15 +2140,15 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05900, TestSize.Level1) } static const struct HksParam RSA_06000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2160,7 +2158,7 @@ static const struct HksParam RSA_06000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest06000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2176,26 +2174,26 @@ HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest06000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp index 7c7df1bb..00d510b4 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp @@ -13,15 +13,13 @@ * limitations under the License. */ -#include "hks_api.h" -#include "hks_mem.h" #include "hks_openssl_rsa_test_mt.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" #include +#include "hks_api.h" +#include "hks_mem.h" + using namespace testing::ext; namespace { namespace { @@ -37,15 +35,15 @@ const int KEY_SIZE_3072 = 3072; class HksRsaEcbOaepSha1Mt : public testing::Test {}; static const struct HksParam RSA_06100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -71,29 +69,29 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -108,15 +106,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06100, TestSize.Level1) } static const struct HksParam RSA_06200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** * @tc.number : HksRsaMtTest06200 @@ -143,29 +141,29 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06200, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -180,15 +178,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06200, TestSize.Level1) } static const struct HksParam RSA_06300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -217,30 +215,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -255,15 +253,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06300, TestSize.Level1) } static const struct HksParam RSA_06400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -292,30 +290,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06400, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -330,15 +328,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06400, TestSize.Level1) } static const struct HksParam RSA_06500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -367,30 +365,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -405,15 +403,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06500, TestSize.Level1) } static const struct HksParam RSA_06600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -442,30 +440,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06600, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -480,15 +478,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06600, TestSize.Level1) } static const struct HksParam RSA_06700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -517,30 +515,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -556,15 +554,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06700, TestSize.Level1) } static const struct HksParam RSA_06800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -574,7 +572,7 @@ static const struct HksParam RSA_06800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -587,21 +585,21 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06800, TestSize.Level1) const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); ASSERT_NE(pkey, nullptr); @@ -626,15 +624,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06800, TestSize.Level1) } static const struct HksParam RSA_06900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -663,30 +661,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -702,15 +700,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06900, TestSize.Level1) } static const struct HksParam RSA_07000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -720,7 +718,7 @@ static const struct HksParam RSA_07000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -733,21 +731,21 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07000, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); ASSERT_NE(pkey, nullptr); @@ -772,15 +770,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07000, TestSize.Level1) } static const struct HksParam RSA_07100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -809,30 +807,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -848,15 +846,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07100, TestSize.Level1) } static const struct HksParam RSA_07200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -866,7 +864,7 @@ static const struct HksParam RSA_07200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -879,21 +877,21 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07200, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); ASSERT_NE(pkey, nullptr); @@ -918,15 +916,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07200, TestSize.Level1) } static const struct HksParam RSA_07300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -955,30 +953,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -994,15 +992,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07300, TestSize.Level1) } static const struct HksParam RSA_07400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1012,7 +1010,7 @@ static const struct HksParam RSA_07400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1025,21 +1023,21 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07400, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); ASSERT_NE(pkey, nullptr); @@ -1064,15 +1062,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07400, TestSize.Level1) } static const struct HksParam RSA_07500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1101,30 +1099,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -1140,15 +1138,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07500, TestSize.Level1) } static const struct HksParam RSA_07600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1158,7 +1156,7 @@ static const struct HksParam RSA_07600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1171,21 +1169,21 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07600, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); ASSERT_NE(pkey, nullptr); @@ -1210,15 +1208,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07600, TestSize.Level1) } static const struct HksParam RSA_07700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1247,30 +1245,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); @@ -1286,15 +1284,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07700, TestSize.Level1) } static const struct HksParam RSA_07800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1304,7 +1302,7 @@ static const struct HksParam RSA_07800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1317,21 +1315,21 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07800, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); ASSERT_NE(pkey, nullptr); @@ -1356,15 +1354,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07800, TestSize.Level1) } static const struct HksParam RSA_07900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1394,30 +1392,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1432,15 +1430,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07900, TestSize.Level1) } static const struct HksParam RSA_08000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1450,7 +1448,7 @@ static const struct HksParam RSA_08000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1466,26 +1464,26 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1499,15 +1497,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08000, TestSize.Level1) } static const struct HksParam RSA_08100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1536,30 +1534,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1574,15 +1572,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08100, TestSize.Level1) } static const struct HksParam RSA_08200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1592,7 +1590,7 @@ static const struct HksParam RSA_08200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1608,26 +1606,26 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08200, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1641,15 +1639,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08200, TestSize.Level1) } static const struct HksParam RSA_08300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1678,30 +1676,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1716,15 +1714,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08300, TestSize.Level1) } static const struct HksParam RSA_08400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1734,7 +1732,7 @@ static const struct HksParam RSA_08400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1750,26 +1748,26 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08400, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1783,15 +1781,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08400, TestSize.Level1) } static const struct HksParam RSA_08500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1820,30 +1818,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1858,15 +1856,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08500, TestSize.Level1) } static const struct HksParam RSA_08600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1876,7 +1874,7 @@ static const struct HksParam RSA_08600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1892,26 +1890,26 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08600, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1925,15 +1923,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08600, TestSize.Level1) } static const struct HksParam RSA_08700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1962,30 +1960,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2000,15 +1998,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08700, TestSize.Level1) } static const struct HksParam RSA_08800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2018,7 +2016,7 @@ static const struct HksParam RSA_08800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2034,26 +2032,26 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08800, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2067,15 +2065,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08800, TestSize.Level1) } static const struct HksParam RSA_08900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2104,30 +2102,30 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2142,15 +2140,15 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08900, TestSize.Level1) } static const struct HksParam RSA_09000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2160,7 +2158,7 @@ static const struct HksParam RSA_09000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest09000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2176,26 +2174,26 @@ HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest09000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp index 6db534e3..95f189b4 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp @@ -13,15 +13,13 @@ * limitations under the License. */ -#include "hks_api.h" -#include "hks_mem.h" #include "hks_openssl_rsa_test_mt.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" #include +#include "hks_api.h" +#include "hks_mem.h" + using namespace testing::ext; namespace { namespace { @@ -37,15 +35,15 @@ const int KEY_SIZE_3072 = 3072; class HksRsaEcbOaepSha224Mt : public testing::Test {}; static const struct HksParam RSA_09100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** * @tc.number : HksRsaMtTest09100 @@ -70,29 +68,29 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "01234"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -107,15 +105,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09100, TestSize.Level1) } static const struct HksParam RSA_09200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -143,29 +141,29 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09200, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -180,15 +178,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09200, TestSize.Level1) } static const struct HksParam RSA_09300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -217,30 +215,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -255,15 +253,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09300, TestSize.Level1) } static const struct HksParam RSA_09400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -292,30 +290,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09400, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -330,15 +328,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09400, TestSize.Level1) } static const struct HksParam RSA_09500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -367,30 +365,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -405,15 +403,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09500, TestSize.Level1) } static const struct HksParam RSA_09600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -442,30 +440,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09600, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -480,15 +478,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09600, TestSize.Level1) } static const struct HksParam RSA_09700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -517,30 +515,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "01234"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -556,15 +554,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09700, TestSize.Level1) } static const struct HksParam RSA_09800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -574,7 +572,7 @@ static const struct HksParam RSA_09800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -587,21 +585,21 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09800, TestSize.Level1) const char *hexData = "01234"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); ASSERT_NE(pkey, nullptr); @@ -627,15 +625,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09800, TestSize.Level1) } static const struct HksParam RSA_09900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -664,30 +662,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -703,15 +701,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09900, TestSize.Level1) } static const struct HksParam RSA_10000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -721,7 +719,7 @@ static const struct HksParam RSA_10000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -734,21 +732,21 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10000, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); ASSERT_NE(pkey, nullptr); @@ -773,15 +771,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10000, TestSize.Level1) HksFreeParamSet(¶mInSet); } static const struct HksParam RSA_10100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -810,30 +808,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -849,15 +847,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10100, TestSize.Level1) } static const struct HksParam RSA_10200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -867,7 +865,7 @@ static const struct HksParam RSA_10200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -880,21 +878,21 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10200, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); ASSERT_NE(pkey, nullptr); @@ -920,15 +918,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10200, TestSize.Level1) } static const struct HksParam RSA_10300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -957,30 +955,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -996,15 +994,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10300, TestSize.Level1) } static const struct HksParam RSA_10400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1014,7 +1012,7 @@ static const struct HksParam RSA_10400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1027,21 +1025,21 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10400, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); ASSERT_NE(pkey, nullptr); @@ -1067,15 +1065,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10400, TestSize.Level1) } static const struct HksParam RSA_10500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1104,30 +1102,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -1143,15 +1141,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10500, TestSize.Level1) } static const struct HksParam RSA_10600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1161,7 +1159,7 @@ static const struct HksParam RSA_10600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1174,21 +1172,21 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10600, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); ASSERT_NE(pkey, nullptr); @@ -1214,15 +1212,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10600, TestSize.Level1) } static const struct HksParam RSA_10700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1251,30 +1249,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); @@ -1290,15 +1288,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10700, TestSize.Level1) } static const struct HksParam RSA_10800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1308,7 +1306,7 @@ static const struct HksParam RSA_10800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1321,21 +1319,21 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10800, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); ASSERT_NE(pkey, nullptr); @@ -1360,15 +1358,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10800, TestSize.Level1) HksFreeParamSet(¶mInSet); } static const struct HksParam RSA_10900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1398,30 +1396,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "012345"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1436,15 +1434,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10900, TestSize.Level1) } static const struct HksParam RSA_11000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1454,7 +1452,7 @@ static const struct HksParam RSA_11000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1470,26 +1468,26 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "01234"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1503,15 +1501,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11000, TestSize.Level1) } static const struct HksParam RSA_11100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1540,30 +1538,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1578,15 +1576,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11100, TestSize.Level1) } static const struct HksParam RSA_11200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1596,7 +1594,7 @@ static const struct HksParam RSA_11200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1612,26 +1610,26 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11200, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1645,15 +1643,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11200, TestSize.Level1) } static const struct HksParam RSA_11300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1682,30 +1680,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1720,15 +1718,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11300, TestSize.Level1) } static const struct HksParam RSA_11400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1738,7 +1736,7 @@ static const struct HksParam RSA_11400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1754,26 +1752,26 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11400, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1787,15 +1785,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11400, TestSize.Level1) } static const struct HksParam RSA_11500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1824,30 +1822,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1862,15 +1860,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11500, TestSize.Level1) } static const struct HksParam RSA_11600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1880,7 +1878,7 @@ static const struct HksParam RSA_11600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1896,26 +1894,26 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11600, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1929,15 +1927,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11600, TestSize.Level1) } static const struct HksParam RSA_11700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1966,30 +1964,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2004,15 +2002,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11700, TestSize.Level1) } static const struct HksParam RSA_11800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2022,7 +2020,7 @@ static const struct HksParam RSA_11800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2038,26 +2036,26 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11800, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2071,15 +2069,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11800, TestSize.Level1) } static const struct HksParam RSA_11900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2108,30 +2106,30 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2146,15 +2144,15 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11900, TestSize.Level1) } static const struct HksParam RSA_12000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2164,7 +2162,7 @@ static const struct HksParam RSA_12000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest12000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2180,26 +2178,26 @@ HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest12000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp index d06b535c..5c7c6be7 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp @@ -13,15 +13,13 @@ * limitations under the License. */ -#include "hks_api.h" -#include "hks_mem.h" #include "hks_openssl_rsa_test_mt.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" #include +#include "hks_api.h" +#include "hks_mem.h" + using namespace testing::ext; namespace { namespace { @@ -37,15 +35,15 @@ const int KEY_SIZE_3072 = 3072; class HksRsaEcbOaepSha256Mt : public testing::Test {}; static const struct HksParam RSA_12100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -71,18 +69,18 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), RSA_FAILED); @@ -94,15 +92,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12100, TestSize.Level1) } static const struct HksParam RSA_12200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -130,18 +128,18 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12200, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), RSA_FAILED); @@ -153,15 +151,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12200, TestSize.Level1) } static const struct HksParam RSA_12300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -190,30 +188,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -228,15 +226,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12300, TestSize.Level1) } static const struct HksParam RSA_12400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -265,30 +263,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12400, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -303,15 +301,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12400, TestSize.Level1) } static const struct HksParam RSA_12500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -340,30 +338,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -378,15 +376,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12500, TestSize.Level1) } static const struct HksParam RSA_12600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -415,30 +413,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12600, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -453,15 +451,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12600, TestSize.Level1) } static const struct HksParam RSA_12700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -489,18 +487,18 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); @@ -512,15 +510,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12700, TestSize.Level1) } static const struct HksParam RSA_12800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -530,7 +528,7 @@ static const struct HksParam RSA_12800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -543,18 +541,18 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12800, TestSize.Level1) const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); ASSERT_NE(pkey, nullptr); @@ -574,15 +572,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12800, TestSize.Level1) } static const struct HksParam RSA_12900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -611,30 +609,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -650,15 +648,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12900, TestSize.Level1) } static const struct HksParam RSA_13000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -668,7 +666,7 @@ static const struct HksParam RSA_13000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -681,21 +679,21 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13000, TestSize.Level1) const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); ASSERT_NE(pkey, nullptr); @@ -721,15 +719,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13000, TestSize.Level1) } static const struct HksParam RSA_13100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -758,30 +756,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -797,15 +795,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13100, TestSize.Level1) } static const struct HksParam RSA_13200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -815,7 +813,7 @@ static const struct HksParam RSA_13200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -828,21 +826,21 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13200, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); ASSERT_NE(pkey, nullptr); @@ -868,15 +866,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13200, TestSize.Level1) } static const struct HksParam RSA_13300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -905,30 +903,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -944,15 +942,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13300, TestSize.Level1) } static const struct HksParam RSA_13400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -962,7 +960,7 @@ static const struct HksParam RSA_13400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -975,21 +973,21 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13400, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); ASSERT_NE(pkey, nullptr); @@ -1015,15 +1013,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13400, TestSize.Level1) } static const struct HksParam RSA_13500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1052,30 +1050,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -1091,15 +1089,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13500, TestSize.Level1) } static const struct HksParam RSA_13600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1109,7 +1107,7 @@ static const struct HksParam RSA_13600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1122,21 +1120,21 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13600, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); ASSERT_NE(pkey, nullptr); @@ -1162,15 +1160,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13600, TestSize.Level1) } static const struct HksParam RSA_13700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1199,30 +1197,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); @@ -1238,15 +1236,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13700, TestSize.Level1) } static const struct HksParam RSA_13800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1256,7 +1254,7 @@ static const struct HksParam RSA_13800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1269,21 +1267,21 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13800, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); ASSERT_NE(pkey, nullptr); @@ -1309,15 +1307,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13800, TestSize.Level1) } static const struct HksParam RSA_13900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1347,18 +1345,18 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), RSA_FAILED); @@ -1370,15 +1368,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13900, TestSize.Level1) } static const struct HksParam RSA_14000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1388,7 +1386,7 @@ static const struct HksParam RSA_14000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1404,23 +1402,23 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), RSA_FAILED); @@ -1431,15 +1429,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14000, TestSize.Level1) } static const struct HksParam RSA_14100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1468,30 +1466,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1506,15 +1504,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14100, TestSize.Level1) } static const struct HksParam RSA_14200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1524,7 +1522,7 @@ static const struct HksParam RSA_14200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1540,26 +1538,26 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14200, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1573,15 +1571,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14200, TestSize.Level1) } static const struct HksParam RSA_14300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1610,30 +1608,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1648,15 +1646,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14300, TestSize.Level1) } static const struct HksParam RSA_14400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1666,7 +1664,7 @@ static const struct HksParam RSA_14400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1682,26 +1680,26 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14400, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1715,15 +1713,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14400, TestSize.Level1) } static const struct HksParam RSA_14500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1752,30 +1750,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1790,15 +1788,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14500, TestSize.Level1) } static const struct HksParam RSA_14600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1808,7 +1806,7 @@ static const struct HksParam RSA_14600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1824,26 +1822,26 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14600, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1857,15 +1855,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14600, TestSize.Level1) } static const struct HksParam RSA_14700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1894,30 +1892,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1932,15 +1930,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14700, TestSize.Level1) } static const struct HksParam RSA_14800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1950,7 +1948,7 @@ static const struct HksParam RSA_14800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1966,26 +1964,26 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14800, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1999,15 +1997,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14800, TestSize.Level1) } static const struct HksParam RSA_14900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2036,30 +2034,30 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2074,15 +2072,15 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14900, TestSize.Level1) } static const struct HksParam RSA_15000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2092,7 +2090,7 @@ static const struct HksParam RSA_15000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt15000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2108,26 +2106,26 @@ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt15000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp index 93904a50..abb9f095 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp @@ -13,15 +13,13 @@ * limitations under the License. */ -#include "hks_api.h" -#include "hks_mem.h" #include "hks_openssl_rsa_test_mt.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" #include +#include "hks_api.h" +#include "hks_mem.h" + using namespace testing::ext; namespace { namespace { @@ -37,15 +35,15 @@ const int KEY_SIZE_3072 = 3072; class HksRsaEcbOaepSha384Mt : public testing::Test {}; static const struct HksParam RSA_15100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -71,18 +69,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); @@ -94,15 +92,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15100, TestSize.Level1) } static const struct HksParam RSA_15200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -130,18 +128,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15200, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); @@ -153,15 +151,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15200, TestSize.Level1) } static const struct HksParam RSA_15300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -190,18 +188,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); @@ -213,15 +211,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15300, TestSize.Level1) } static const struct HksParam RSA_15400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -250,30 +248,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15400, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); @@ -288,15 +286,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15400, TestSize.Level1) } static const struct HksParam RSA_15500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -325,30 +323,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); @@ -363,15 +361,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15500, TestSize.Level1) } static const struct HksParam RSA_15600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -400,30 +398,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15600, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); @@ -438,15 +436,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15600, TestSize.Level1) } static const struct HksParam RSA_15700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -475,18 +473,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); @@ -498,15 +496,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15700, TestSize.Level1) } static const struct HksParam RSA_15800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -516,7 +514,7 @@ static const struct HksParam RSA_15800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -529,18 +527,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15800, TestSize.Level1) const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); ASSERT_NE(pkey, nullptr); @@ -560,15 +558,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15800, TestSize.Level1) } static const struct HksParam RSA_15900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -597,18 +595,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); @@ -620,15 +618,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15900, TestSize.Level1) } static const struct HksParam RSA_16000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -638,7 +636,7 @@ static const struct HksParam RSA_16000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -651,18 +649,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16000, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); ASSERT_NE(pkey, nullptr); @@ -682,15 +680,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16000, TestSize.Level1) } static const struct HksParam RSA_16100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -719,30 +717,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); @@ -758,15 +756,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16100, TestSize.Level1) } static const struct HksParam RSA_16200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -776,7 +774,7 @@ static const struct HksParam RSA_16200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -789,21 +787,21 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16200, TestSize.Level1) const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); ASSERT_NE(pkey, nullptr); @@ -829,15 +827,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16200, TestSize.Level1) } static const struct HksParam RSA_16300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -866,30 +864,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); @@ -905,15 +903,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16300, TestSize.Level1) } static const struct HksParam RSA_16400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -923,7 +921,7 @@ static const struct HksParam RSA_16400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -936,21 +934,21 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16400, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); ASSERT_NE(pkey, nullptr); @@ -976,15 +974,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16400, TestSize.Level1) } static const struct HksParam RSA_16500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1013,30 +1011,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); @@ -1052,15 +1050,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16500, TestSize.Level1) } static const struct HksParam RSA_16600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1070,7 +1068,7 @@ static const struct HksParam RSA_16600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1083,21 +1081,21 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16600, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); ASSERT_NE(pkey, nullptr); @@ -1123,15 +1121,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16600, TestSize.Level1) } static const struct HksParam RSA_16700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1160,30 +1158,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); @@ -1199,15 +1197,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16700, TestSize.Level1) } static const struct HksParam RSA_16800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1217,7 +1215,7 @@ static const struct HksParam RSA_16800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1230,21 +1228,21 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16800, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); ASSERT_NE(pkey, nullptr); @@ -1270,15 +1268,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16800, TestSize.Level1) } static const struct HksParam RSA_16900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1308,18 +1306,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); @@ -1331,15 +1329,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16900, TestSize.Level1) } static const struct HksParam RSA_17000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1349,7 +1347,7 @@ static const struct HksParam RSA_17000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1365,23 +1363,23 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); @@ -1392,15 +1390,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17000, TestSize.Level1) } static const struct HksParam RSA_17100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1429,18 +1427,18 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); @@ -1452,15 +1450,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17100, TestSize.Level1) } static const struct HksParam RSA_17200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1470,7 +1468,7 @@ static const struct HksParam RSA_17200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1486,23 +1484,23 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17200, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); @@ -1513,15 +1511,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17200, TestSize.Level1) } static const struct HksParam RSA_17300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1550,30 +1548,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1588,15 +1586,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17300, TestSize.Level1) } static const struct HksParam RSA_17400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1606,7 +1604,7 @@ static const struct HksParam RSA_17400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1622,26 +1620,26 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17400, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1655,15 +1653,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17400, TestSize.Level1) } static const struct HksParam RSA_17500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1692,30 +1690,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1730,15 +1728,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17500, TestSize.Level1) } static const struct HksParam RSA_17600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1748,7 +1746,7 @@ static const struct HksParam RSA_17600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1764,26 +1762,26 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17600, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1797,15 +1795,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17600, TestSize.Level1) } static const struct HksParam RSA_17700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1834,30 +1832,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1872,15 +1870,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17700, TestSize.Level1) } static const struct HksParam RSA_17800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1890,7 +1888,7 @@ static const struct HksParam RSA_17800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1906,26 +1904,26 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17800, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1939,15 +1937,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17800, TestSize.Level1) } static const struct HksParam RSA_17900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1976,30 +1974,30 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2014,15 +2012,15 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17900, TestSize.Level1) } static const struct HksParam RSA_18000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2032,7 +2030,7 @@ static const struct HksParam RSA_18000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt18000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2048,26 +2046,26 @@ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt18000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp index a03fff07..92f70aa0 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp @@ -13,15 +13,13 @@ * limitations under the License. */ -#include "hks_api.h" -#include "hks_mem.h" #include "hks_openssl_rsa_test_mt.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" #include +#include "hks_api.h" +#include "hks_mem.h" + using namespace testing::ext; namespace { namespace { @@ -37,15 +35,15 @@ const int KEY_SIZE_3072 = 3072; class HksRsaEcbOaepSha512Mt : public testing::Test {}; static const struct HksParam RSA_18100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -71,18 +69,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -94,15 +92,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18100, TestSize.Level1) } static const struct HksParam RSA_18200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -130,18 +128,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18200, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -153,15 +151,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18200, TestSize.Level1) } static const struct HksParam RSA_18300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -190,18 +188,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -213,15 +211,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18300, TestSize.Level1) } static const struct HksParam RSA_18400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -250,30 +248,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18400, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); @@ -288,15 +286,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18400, TestSize.Level1) } static const struct HksParam RSA_18500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -325,30 +323,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); @@ -363,15 +361,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18500, TestSize.Level1) } static const struct HksParam RSA_18600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -400,30 +398,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18600, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); @@ -438,15 +436,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18600, TestSize.Level1) } static const struct HksParam RSA_18700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -475,18 +473,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); @@ -498,15 +496,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18700, TestSize.Level1) } static const struct HksParam RSA_18800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -516,7 +514,7 @@ static const struct HksParam RSA_18800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -529,18 +527,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18800, TestSize.Level1) const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); ASSERT_NE(pkey, nullptr); @@ -560,15 +558,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18800, TestSize.Level1) } static const struct HksParam RSA_18900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -597,18 +595,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); @@ -620,15 +618,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18900, TestSize.Level1) } static const struct HksParam RSA_19000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -638,7 +636,7 @@ static const struct HksParam RSA_19000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -651,18 +649,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19000, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); ASSERT_NE(pkey, nullptr); @@ -682,15 +680,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19000, TestSize.Level1) } static const struct HksParam RSA_19100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -719,18 +717,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); @@ -742,15 +740,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19100, TestSize.Level1) } static const struct HksParam RSA_19200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -760,7 +758,7 @@ static const struct HksParam RSA_19200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -773,18 +771,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19200, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); ASSERT_NE(pkey, nullptr); @@ -804,15 +802,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19200, TestSize.Level1) } static const struct HksParam RSA_19300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -841,30 +839,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); @@ -880,15 +878,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19300, TestSize.Level1) } static const struct HksParam RSA_19400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -898,7 +896,7 @@ static const struct HksParam RSA_19400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -911,21 +909,21 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19400, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); ASSERT_NE(pkey, nullptr); @@ -951,15 +949,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19400, TestSize.Level1) } static const struct HksParam RSA_19500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -988,30 +986,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); @@ -1027,15 +1025,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19500, TestSize.Level1) } static const struct HksParam RSA_19600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1045,7 +1043,7 @@ static const struct HksParam RSA_19600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1058,21 +1056,21 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19600, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); ASSERT_NE(pkey, nullptr); @@ -1098,15 +1096,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19600, TestSize.Level1) } static const struct HksParam RSA_19700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1135,30 +1133,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); @@ -1174,15 +1172,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19700, TestSize.Level1) } static const struct HksParam RSA_19800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1192,7 +1190,7 @@ static const struct HksParam RSA_19800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1205,21 +1203,21 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19800, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); ASSERT_NE(pkey, nullptr); @@ -1245,15 +1243,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19800, TestSize.Level1) } static const struct HksParam RSA_19900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1283,18 +1281,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -1306,15 +1304,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19900, TestSize.Level1) } static const struct HksParam RSA_20000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1324,7 +1322,7 @@ static const struct HksParam RSA_20000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1340,23 +1338,23 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -1367,15 +1365,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20000, TestSize.Level1) } static const struct HksParam RSA_20100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1404,18 +1402,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -1427,15 +1425,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20100, TestSize.Level1) } static const struct HksParam RSA_20200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1445,7 +1443,7 @@ static const struct HksParam RSA_20200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1461,23 +1459,23 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20200, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -1488,15 +1486,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20200, TestSize.Level1) } static const struct HksParam RSA_20300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1525,18 +1523,18 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -1548,15 +1546,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20300, TestSize.Level1) } static const struct HksParam RSA_20400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1566,7 +1564,7 @@ static const struct HksParam RSA_20400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1582,23 +1580,23 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20400, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); @@ -1609,15 +1607,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20400, TestSize.Level1) } static const struct HksParam RSA_20500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1646,30 +1644,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1684,15 +1682,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20500, TestSize.Level1) } static const struct HksParam RSA_20600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1702,7 +1700,7 @@ static const struct HksParam RSA_20600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1718,26 +1716,26 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20600, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1751,15 +1749,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20600, TestSize.Level1) } static const struct HksParam RSA_20700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1788,30 +1786,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1826,15 +1824,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20700, TestSize.Level1) } static const struct HksParam RSA_20800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1844,7 +1842,7 @@ static const struct HksParam RSA_20800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1860,26 +1858,26 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20800, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1893,15 +1891,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20800, TestSize.Level1) } static const struct HksParam RSA_20900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1930,30 +1928,30 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1968,15 +1966,15 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20900, TestSize.Level1) } static const struct HksParam RSA_21000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1986,7 +1984,7 @@ static const struct HksParam RSA_21000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt21000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2002,26 +2000,26 @@ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt21000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp index b43dcda7..db6c852b 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp @@ -13,15 +13,13 @@ * limitations under the License. */ -#include "hks_api.h" -#include "hks_mem.h" #include "hks_openssl_rsa_test_mt.h" -#include "hks_param.h" -#include "hks_test_common.h" -#include "hks_test_log.h" #include +#include "hks_api.h" +#include "hks_mem.h" + using namespace testing::ext; namespace { namespace { @@ -37,15 +35,15 @@ const int KEY_SIZE_3072 = 3072; class HksRsaEcbPkcs1PaddingMt : public testing::Test {}; static const struct HksParam RSA_21100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -72,29 +70,29 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -108,15 +106,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21100, TestSize.Level1) HksFreeParamSet(¶mInSet); } static const struct HksParam RSA_21200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -145,29 +143,29 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21200, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -182,15 +180,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21200, TestSize.Level1) } static const struct HksParam RSA_21300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -220,30 +218,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -258,15 +256,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21300, TestSize.Level1) } static const struct HksParam RSA_21400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -296,30 +294,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21400, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -334,15 +332,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21400, TestSize.Level1) } static const struct HksParam RSA_21500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -372,30 +370,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -410,15 +408,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21500, TestSize.Level1) } static const struct HksParam RSA_21600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -448,30 +446,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21600, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -486,15 +484,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21600, TestSize.Level1) } static const struct HksParam RSA_21700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -524,30 +522,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -563,15 +561,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21700, TestSize.Level1) } static const struct HksParam RSA_21800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -582,7 +580,7 @@ static const struct HksParam RSA_21800_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -595,21 +593,21 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21800, TestSize.Level1) const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); ASSERT_NE(pkey, nullptr); @@ -635,15 +633,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21800, TestSize.Level1) } static const struct HksParam RSA_21900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -672,30 +670,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -711,15 +709,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21900, TestSize.Level1) } static const struct HksParam RSA_22000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -730,7 +728,7 @@ static const struct HksParam RSA_22000_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -743,21 +741,21 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22000, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); ASSERT_NE(pkey, nullptr); @@ -783,15 +781,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22000, TestSize.Level1) } static const struct HksParam RSA_22100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -821,30 +819,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -860,15 +858,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22100, TestSize.Level1) } static const struct HksParam RSA_22200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -879,7 +877,7 @@ static const struct HksParam RSA_22200_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -892,21 +890,21 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22200, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); ASSERT_NE(pkey, nullptr); @@ -932,15 +930,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22200, TestSize.Level1) } static const struct HksParam RSA_22300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -970,30 +968,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -1009,15 +1007,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22300, TestSize.Level1) } static const struct HksParam RSA_22400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1028,7 +1026,7 @@ static const struct HksParam RSA_22400_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1041,21 +1039,21 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22400, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); ASSERT_NE(pkey, nullptr); @@ -1081,15 +1079,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22400, TestSize.Level1) } static const struct HksParam RSA_22500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1119,30 +1117,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -1158,15 +1156,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22500, TestSize.Level1) } static const struct HksParam RSA_22600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1177,7 +1175,7 @@ static const struct HksParam RSA_22600_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1190,21 +1188,21 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22600, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); ASSERT_NE(pkey, nullptr); @@ -1230,15 +1228,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22600, TestSize.Level1) } static const struct HksParam RSA_22700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1268,30 +1266,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); @@ -1307,15 +1305,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22700, TestSize.Level1) } static const struct HksParam RSA_22800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1326,7 +1324,7 @@ static const struct HksParam RSA_22800_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); @@ -1339,21 +1337,21 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22800, TestSize.Level1) const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLen, .data = (uint8_t *)malloc(inLen)}; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); - struct HksBlob opensslRsaKeyInfo = {.size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096)}; + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - struct HksBlob x509Key = {0, NULL}; + struct HksBlob x509Key = { 0, NULL }; EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); ASSERT_NE(pkey, nullptr); @@ -1379,15 +1377,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22800, TestSize.Level1) } static const struct HksParam RSA_22900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1418,30 +1416,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1456,15 +1454,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22900, TestSize.Level1) } static const struct HksParam RSA_23000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1475,7 +1473,7 @@ static const struct HksParam RSA_23000_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1491,26 +1489,26 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1524,15 +1522,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23000, TestSize.Level1) } static const struct HksParam RSA_23100_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1562,30 +1560,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23100, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1600,15 +1598,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23100, TestSize.Level1) } static const struct HksParam RSA_23200_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1619,7 +1617,7 @@ static const struct HksParam RSA_23200_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23200, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1635,26 +1633,26 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23200, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1668,15 +1666,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23200, TestSize.Level1) } static const struct HksParam RSA_23300_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1706,30 +1704,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23300, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1744,15 +1742,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23300, TestSize.Level1) } static const struct HksParam RSA_23400_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1763,7 +1761,7 @@ static const struct HksParam RSA_23400_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23400, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1779,26 +1777,26 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23400, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1812,15 +1810,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23400, TestSize.Level1) } static const struct HksParam RSA_23500_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1850,30 +1848,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23500, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1888,15 +1886,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23500, TestSize.Level1) } static const struct HksParam RSA_23600_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1907,7 +1905,7 @@ static const struct HksParam RSA_23600_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23600, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -1923,26 +1921,26 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23600, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -1956,15 +1954,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23600, TestSize.Level1) } static const struct HksParam RSA_23700_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -1994,30 +1992,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23700, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2032,15 +2030,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23700, TestSize.Level1) } static const struct HksParam RSA_23800_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2051,7 +2049,7 @@ static const struct HksParam RSA_23800_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23800, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2067,26 +2065,26 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23800, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2100,15 +2098,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23800, TestSize.Level1) } static const struct HksParam RSA_23900_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2138,30 +2136,30 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23900, TestSize.Level1) HksParam *pubKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = {.size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size)}; + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; ASSERT_NE(publicKey.data, nullptr); (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); HksParam *priKeyExport = NULL; EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = {.size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size)}; + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; ASSERT_NE(privateKey.data, nullptr); (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); @@ -2176,15 +2174,15 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23900, TestSize.Level1) } static const struct HksParam RSA_24000_PARAMS[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE}, - {.tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - {.tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB}, + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; /** @@ -2195,7 +2193,7 @@ static const struct HksParam RSA_24000_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt24000, TestSize.Level1) { - struct HksBlob authId = {strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID}; + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; struct HksParamSet *paramInSet = NULL; HksInitParamSet(¶mInSet); ASSERT_NE(paramInSet, nullptr); @@ -2211,26 +2209,26 @@ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt24000, TestSize.Level1) EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = {opensslRsaKeyLen, opensslRsaKey}; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = {rsaPublicKeyLen, rsaPublicKey}; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = {.size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size)}; + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); const char *hexData = "00112233445566778899aabbccddeeff"; - HksBlob plainText = {.size = strlen(hexData), .data = (uint8_t *)hexData}; + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; HksParam *cipherLenBit = NULL; HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = {.size = inLength, .data = (uint8_t *)malloc(inLength)}; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; ASSERT_NE(cipherText.data, nullptr); EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = {.size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096)}; + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; ASSERT_NE(decryptedText.data, nullptr); EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp new file mode 100755 index 00000000..64b960f3 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp @@ -0,0 +1,1596 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for MD5"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaMd5WithRsaMt : public testing::Test {}; + +static const struct HksParam RSA_24100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24100 + * @tc.name : HksRsaMtTest24100 + * @tc.desc : Test huks sign (512/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24100_PARAMS, sizeof(RSA_24100_PARAMS) / sizeof(RSA_24100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_24200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24200 + * @tc.name : HksRsaMtTest24200 + * @tc.desc : Test huks sign (512/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24200_PARAMS, sizeof(RSA_24200_PARAMS) / sizeof(RSA_24200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_24300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24300 + * @tc.name : HksRsaMtTest24300 + * @tc.desc : Test huks Verify (512/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24300_PARAMS, sizeof(RSA_24300_PARAMS) / sizeof(RSA_24300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_24400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24400 + * @tc.name : HksRsaMtTest24400 + * @tc.desc : Test huks Verify (512/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24400_PARAMS, sizeof(RSA_24400_PARAMS) / sizeof(RSA_24400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_24500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24500 + * @tc.name : HksRsaMtTest24500 + * @tc.desc : Test huks sign (768/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24500_PARAMS, sizeof(RSA_24500_PARAMS) / sizeof(RSA_24500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_24600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24600 + * @tc.name : HksRsaMtTest24600 + * @tc.desc : Test huks sign (768/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24600_PARAMS, sizeof(RSA_24600_PARAMS) / sizeof(RSA_24600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_24700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24700 + * @tc.name : HksRsaMtTest24700 + * @tc.desc : Test huks Verify (768/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24700_PARAMS, sizeof(RSA_24700_PARAMS) / sizeof(RSA_24700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_24800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24800 + * @tc.name : HksRsaMtTest24800 + * @tc.desc : Test huks Verify (768/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24800_PARAMS, sizeof(RSA_24800_PARAMS) / sizeof(RSA_24800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_24900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest24900 + * @tc.name : HksRsaMtTest24900 + * @tc.desc : Test huks sign (1024/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_24900_PARAMS, sizeof(RSA_24900_PARAMS) / sizeof(RSA_24900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25000 + * @tc.name : HksRsaMtTest25000 + * @tc.desc : Test huks sign (1024/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25000_PARAMS, sizeof(RSA_25000_PARAMS) / sizeof(RSA_25000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25100 + * @tc.name : HksRsaMtTest25100 + * @tc.desc : Test huks Verify (1024/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25100_PARAMS, sizeof(RSA_25100_PARAMS) / sizeof(RSA_25100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25200 + * @tc.name : HksRsaMtTest25200 + * @tc.desc : Test huks Verify (1024/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25200_PARAMS, sizeof(RSA_25200_PARAMS) / sizeof(RSA_25200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25300 + * @tc.name : HksRsaMtTest25300 + * @tc.desc : Test huks sign (2048/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25300_PARAMS, sizeof(RSA_25300_PARAMS) / sizeof(RSA_25300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25400 + * @tc.name : HksRsaMtTest25400 + * @tc.desc : Test huks sign (2048/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25400_PARAMS, sizeof(RSA_25400_PARAMS) / sizeof(RSA_25400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25500 + * @tc.name : HksRsaMtTest25500 + * @tc.desc : Test huks Verify (2048/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25500_PARAMS, sizeof(RSA_25500_PARAMS) / sizeof(RSA_25500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25600 + * @tc.name : HksRsaMtTest25600 + * @tc.desc : Test huks Verify (2048/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25600_PARAMS, sizeof(RSA_25600_PARAMS) / sizeof(RSA_25600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25700 + * @tc.name : HksRsaMtTest25700 + * @tc.desc : Test huks sign (3072/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25700_PARAMS, sizeof(RSA_25700_PARAMS) / sizeof(RSA_25700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25800 + * @tc.name : HksRsaMtTest25800 + * @tc.desc : Test huks sign (3072/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25800_PARAMS, sizeof(RSA_25800_PARAMS) / sizeof(RSA_25800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_25900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest25900 + * @tc.name : HksRsaMtTest25900 + * @tc.desc : Test huks Verify (3072/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_25900_PARAMS, sizeof(RSA_25900_PARAMS) / sizeof(RSA_25900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26000 + * @tc.name : HksRsaMtTest26000 + * @tc.desc : Test huks Verify (3072/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26000_PARAMS, sizeof(RSA_26000_PARAMS) / sizeof(RSA_26000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26100 + * @tc.name : HksRsaMtTest26100 + * @tc.desc : Test huks sign (4096/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26100_PARAMS, sizeof(RSA_26100_PARAMS) / sizeof(RSA_26100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26200 + * @tc.name : HksRsaMtTest26200 + * @tc.desc : Test huks sign (4096/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26200_PARAMS, sizeof(RSA_26200_PARAMS) / sizeof(RSA_26200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26300 + * @tc.name : HksRsaMtTest26300 + * @tc.desc : Test huks Verify (4096/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26300_PARAMS, sizeof(RSA_26300_PARAMS) / sizeof(RSA_26300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26400 + * @tc.name : HksRsaMtTest26400 + * @tc.desc : Test huks Verify (4096/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26400_PARAMS, sizeof(RSA_26400_PARAMS) / sizeof(RSA_26400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp new file mode 100755 index 00000000..b27e3298 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp @@ -0,0 +1,1596 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for NONE"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaNoneWithRsaMt : public testing::Test {}; + +static const struct HksParam RSA_26500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26500 + * @tc.name : HksRsaMtTest26500 + * @tc.desc : Test huks sign (512/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26500_PARAMS, sizeof(RSA_26500_PARAMS) / sizeof(RSA_26500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26600 + * @tc.name : HksRsaMtTest26600 + * @tc.desc : Test huks sign (512/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26600_PARAMS, sizeof(RSA_26600_PARAMS) / sizeof(RSA_26600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26700 + * @tc.name : HksRsaMtTest26700 + * @tc.desc : Test huks Verify (512/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26700_PARAMS, sizeof(RSA_26700_PARAMS) / sizeof(RSA_26700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26800 + * @tc.name : HksRsaMtTest26800 + * @tc.desc : Test huks Verify (512/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26800_PARAMS, sizeof(RSA_26800_PARAMS) / sizeof(RSA_26800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_26900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest26900 + * @tc.name : HksRsaMtTest26900 + * @tc.desc : Test huks sign (768/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_26900_PARAMS, sizeof(RSA_26900_PARAMS) / sizeof(RSA_26900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27000 + * @tc.name : HksRsaMtTest27000 + * @tc.desc : Test huks sign (768/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27000_PARAMS, sizeof(RSA_27000_PARAMS) / sizeof(RSA_27000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27100 + * @tc.name : HksRsaMtTest27100 + * @tc.desc : Test huks Verify (768/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27100_PARAMS, sizeof(RSA_27100_PARAMS) / sizeof(RSA_27100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27200 + * @tc.name : HksRsaMtTest27200 + * @tc.desc : Test huks Verify (768/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27200_PARAMS, sizeof(RSA_27200_PARAMS) / sizeof(RSA_27200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27300 + * @tc.name : HksRsaMtTest27300 + * @tc.desc : Test huks sign (1024/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27300_PARAMS, sizeof(RSA_27300_PARAMS) / sizeof(RSA_27300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27400 + * @tc.name : HksRsaMtTest27400 + * @tc.desc : Test huks sign (1024/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27400_PARAMS, sizeof(RSA_27400_PARAMS) / sizeof(RSA_27400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27500 + * @tc.name : HksRsaMtTest27500 + * @tc.desc : Test huks Verify (1024/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27500_PARAMS, sizeof(RSA_27500_PARAMS) / sizeof(RSA_27500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27600 + * @tc.name : HksRsaMtTest27600 + * @tc.desc : Test huks Verify (1024/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27600_PARAMS, sizeof(RSA_27600_PARAMS) / sizeof(RSA_27600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27700 + * @tc.name : HksRsaMtTest27700 + * @tc.desc : Test huks sign (2048/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27700_PARAMS, sizeof(RSA_27700_PARAMS) / sizeof(RSA_27700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27800 + * @tc.name : HksRsaMtTest27800 + * @tc.desc : Test huks sign (2048/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27800_PARAMS, sizeof(RSA_27800_PARAMS) / sizeof(RSA_27800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_27900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest27900 + * @tc.name : HksRsaMtTest27900 + * @tc.desc : Test huks Verify (2048/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_27900_PARAMS, sizeof(RSA_27900_PARAMS) / sizeof(RSA_27900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28000 + * @tc.name : HksRsaMtTest28000 + * @tc.desc : Test huks Verify (2048/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28000_PARAMS, sizeof(RSA_28000_PARAMS) / sizeof(RSA_28000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28100 + * @tc.name : HksRsaMtTest28100 + * @tc.desc : Test huks sign (3072/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28100_PARAMS, sizeof(RSA_28100_PARAMS) / sizeof(RSA_28100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28200 + * @tc.name : HksRsaMtTest28200 + * @tc.desc : Test huks sign (3072/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28200_PARAMS, sizeof(RSA_28200_PARAMS) / sizeof(RSA_28200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28300 + * @tc.name : HksRsaMtTest28300 + * @tc.desc : Test huks Verify (3072/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28300_PARAMS, sizeof(RSA_28300_PARAMS) / sizeof(RSA_28300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28400 + * @tc.name : HksRsaMtTest28400 + * @tc.desc : Test huks Verify (3072/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28400_PARAMS, sizeof(RSA_28400_PARAMS) / sizeof(RSA_28400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28500 + * @tc.name : HksRsaMtTest28500 + * @tc.desc : Test huks sign (4096/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28500_PARAMS, sizeof(RSA_28500_PARAMS) / sizeof(RSA_28500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28600 + * @tc.name : HksRsaMtTest28600 + * @tc.desc : Test huks sign (4096/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28600_PARAMS, sizeof(RSA_28600_PARAMS) / sizeof(RSA_28600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28700 + * @tc.name : HksRsaMtTest28700 + * @tc.desc : Test huks Verify (4096/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28700_PARAMS, sizeof(RSA_28700_PARAMS) / sizeof(RSA_28700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_28800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28800 + * @tc.name : HksRsaMtTest28800 + * @tc.desc : Test huks Verify (4096/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28800_PARAMS, sizeof(RSA_28800_PARAMS) / sizeof(RSA_28800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp new file mode 100755 index 00000000..c4f17bcc --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp @@ -0,0 +1,1596 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA1"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha1WithRsaMt : public testing::Test {}; + +static const struct HksParam RSA_28900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest28900 + * @tc.name : HksRsaMtTest28900 + * @tc.desc : Test huks sign (512/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest28900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_28900_PARAMS, sizeof(RSA_28900_PARAMS) / sizeof(RSA_28900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29000 + * @tc.name : HksRsaMtTest29000 + * @tc.desc : Test huks sign (512/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29000_PARAMS, sizeof(RSA_29000_PARAMS) / sizeof(RSA_29000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29100 + * @tc.name : HksRsaMtTest29100 + * @tc.desc : Test huks Verify (512/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29100_PARAMS, sizeof(RSA_29100_PARAMS) / sizeof(RSA_29100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29200 + * @tc.name : HksRsaMtTest29200 + * @tc.desc : Test huks Verify (512/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29200_PARAMS, sizeof(RSA_29200_PARAMS) / sizeof(RSA_29200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29300 + * @tc.name : HksRsaMtTest29300 + * @tc.desc : Test huks sign (768/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29300_PARAMS, sizeof(RSA_29300_PARAMS) / sizeof(RSA_29300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29400 + * @tc.name : HksRsaMtTest29400 + * @tc.desc : Test huks sign (768/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29400_PARAMS, sizeof(RSA_29400_PARAMS) / sizeof(RSA_29400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29500 + * @tc.name : HksRsaMtTest29500 + * @tc.desc : Test huks Verify (768/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29500_PARAMS, sizeof(RSA_29500_PARAMS) / sizeof(RSA_29500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29600 + * @tc.name : HksRsaMtTest29600 + * @tc.desc : Test huks Verify (768/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29600_PARAMS, sizeof(RSA_29600_PARAMS) / sizeof(RSA_29600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29700 + * @tc.name : HksRsaMtTest29700 + * @tc.desc : Test huks sign (1024/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29700_PARAMS, sizeof(RSA_29700_PARAMS) / sizeof(RSA_29700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29800 + * @tc.name : HksRsaMtTest29800 + * @tc.desc : Test huks sign (1024/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29800_PARAMS, sizeof(RSA_29800_PARAMS) / sizeof(RSA_29800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_29900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest29900 + * @tc.name : HksRsaMtTest29900 + * @tc.desc : Test huks Verify (1024/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_29900_PARAMS, sizeof(RSA_29900_PARAMS) / sizeof(RSA_29900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30000 + * @tc.name : HksRsaMtTest30000 + * @tc.desc : Test huks Verify (1024/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30000_PARAMS, sizeof(RSA_30000_PARAMS) / sizeof(RSA_30000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30100 + * @tc.name : HksRsaMtTest30100 + * @tc.desc : Test huks sign (2048/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30100_PARAMS, sizeof(RSA_30100_PARAMS) / sizeof(RSA_30100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30200 + * @tc.name : HksRsaMtTest30200 + * @tc.desc : Test huks sign (2048/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30200_PARAMS, sizeof(RSA_30200_PARAMS) / sizeof(RSA_30200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30300 + * @tc.name : HksRsaMtTest30300 + * @tc.desc : Test huks Verify (2048/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30300_PARAMS, sizeof(RSA_30300_PARAMS) / sizeof(RSA_30300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30400 + * @tc.name : HksRsaMtTest30400 + * @tc.desc : Test huks Verify (2048/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30400_PARAMS, sizeof(RSA_30400_PARAMS) / sizeof(RSA_30400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30500 + * @tc.name : HksRsaMtTest30500 + * @tc.desc : Test huks sign (3072/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30500_PARAMS, sizeof(RSA_30500_PARAMS) / sizeof(RSA_30500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30600 + * @tc.name : HksRsaMtTest30600 + * @tc.desc : Test huks sign (3072/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30600_PARAMS, sizeof(RSA_30600_PARAMS) / sizeof(RSA_30600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30700 + * @tc.name : HksRsaMtTest30700 + * @tc.desc : Test huks Verify (3072/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30700_PARAMS, sizeof(RSA_30700_PARAMS) / sizeof(RSA_30700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30800 + * @tc.name : HksRsaMtTest30800 + * @tc.desc : Test huks Verify (3072/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30800_PARAMS, sizeof(RSA_30800_PARAMS) / sizeof(RSA_30800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_30900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest30900 + * @tc.name : HksRsaMtTest30900 + * @tc.desc : Test huks sign (4096/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_30900_PARAMS, sizeof(RSA_30900_PARAMS) / sizeof(RSA_30900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31000 + * @tc.name : HksRsaMtTest31000 + * @tc.desc : Test huks sign (4096/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest31000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31000_PARAMS, sizeof(RSA_31000_PARAMS) / sizeof(RSA_31000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31100 + * @tc.name : HksRsaMtTest31100 + * @tc.desc : Test huks Verify (4096/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest31100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31100_PARAMS, sizeof(RSA_31100_PARAMS) / sizeof(RSA_31100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31200 + * @tc.name : HksRsaMtTest31200 + * @tc.desc : Test huks Verify (4096/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest31200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31200_PARAMS, sizeof(RSA_31200_PARAMS) / sizeof(RSA_31200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp new file mode 100755 index 00000000..e7800bbd --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp @@ -0,0 +1,1596 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha1AndPss"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha1WithRsaPssMt : public testing::Test {}; + +static const struct HksParam RSA_31300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31300 + * @tc.name : HksRsaMtTest31300 + * @tc.desc : Test huks sign (512/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31300_PARAMS, sizeof(RSA_31300_PARAMS) / sizeof(RSA_31300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31400 + * @tc.name : HksRsaMtTest31400 + * @tc.desc : Test huks sign (512/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31400_PARAMS, sizeof(RSA_31400_PARAMS) / sizeof(RSA_31400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31500 + * @tc.name : HksRsaMtTest31500 + * @tc.desc : Test huks Verify (512/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31500_PARAMS, sizeof(RSA_31500_PARAMS) / sizeof(RSA_31500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31600 + * @tc.name : HksRsaMtTest31600 + * @tc.desc : Test huks Verify (512/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31600_PARAMS, sizeof(RSA_31600_PARAMS) / sizeof(RSA_31600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31700 + * @tc.name : HksRsaMtTest31700 + * @tc.desc : Test huks sign (768/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31700_PARAMS, sizeof(RSA_31700_PARAMS) / sizeof(RSA_31700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31800 + * @tc.name : HksRsaMtTest31800 + * @tc.desc : Test huks sign (768/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31800_PARAMS, sizeof(RSA_31800_PARAMS) / sizeof(RSA_31800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_31900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest31900 + * @tc.name : HksRsaMtTest31900 + * @tc.desc : Test huks Verify (768/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_31900_PARAMS, sizeof(RSA_31900_PARAMS) / sizeof(RSA_31900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32000 + * @tc.name : HksRsaMtTest32000 + * @tc.desc : Test huks Verify (768/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32000_PARAMS, sizeof(RSA_32000_PARAMS) / sizeof(RSA_32000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32100 + * @tc.name : HksRsaMtTest32100 + * @tc.desc : Test huks sign (1024/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32100_PARAMS, sizeof(RSA_32100_PARAMS) / sizeof(RSA_32100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32200 + * @tc.name : HksRsaMtTest32200 + * @tc.desc : Test huks sign (1024/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32200_PARAMS, sizeof(RSA_32200_PARAMS) / sizeof(RSA_32200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32300 + * @tc.name : HksRsaMtTest32300 + * @tc.desc : Test huks Verify (1024/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32300_PARAMS, sizeof(RSA_32300_PARAMS) / sizeof(RSA_32300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32400 + * @tc.name : HksRsaMtTest32400 + * @tc.desc : Test huks Verify (1024/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32400_PARAMS, sizeof(RSA_32400_PARAMS) / sizeof(RSA_32400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32500 + * @tc.name : HksRsaMtTest32500 + * @tc.desc : Test huks sign (2048/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32500_PARAMS, sizeof(RSA_32500_PARAMS) / sizeof(RSA_32500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32600 + * @tc.name : HksRsaMtTest32600 + * @tc.desc : Test huks sign (2048/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32600_PARAMS, sizeof(RSA_32600_PARAMS) / sizeof(RSA_32600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32700 + * @tc.name : HksRsaMtTest32700 + * @tc.desc : Test huks Verify (2048/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32700_PARAMS, sizeof(RSA_32700_PARAMS) / sizeof(RSA_32700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32800 + * @tc.name : HksRsaMtTest32800 + * @tc.desc : Test huks Verify (2048/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32800_PARAMS, sizeof(RSA_32800_PARAMS) / sizeof(RSA_32800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_32900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest32900 + * @tc.name : HksRsaMtTest32900 + * @tc.desc : Test huks sign (3072/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_32900_PARAMS, sizeof(RSA_32900_PARAMS) / sizeof(RSA_32900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33000 + * @tc.name : HksRsaMtTest33000 + * @tc.desc : Test huks sign (3072/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33000_PARAMS, sizeof(RSA_33000_PARAMS) / sizeof(RSA_33000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33100 + * @tc.name : HksRsaMtTest33100 + * @tc.desc : Test huks Verify (3072/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33100_PARAMS, sizeof(RSA_33100_PARAMS) / sizeof(RSA_33100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33200 + * @tc.name : HksRsaMtTest33200 + * @tc.desc : Test huks Verify (3072/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33200_PARAMS, sizeof(RSA_33200_PARAMS) / sizeof(RSA_33200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33300 + * @tc.name : HksRsaMtTest33300 + * @tc.desc : Test huks sign (4096/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33300_PARAMS, sizeof(RSA_33300_PARAMS) / sizeof(RSA_33300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33400 + * @tc.name : HksRsaMtTest33400 + * @tc.desc : Test huks sign (4096/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33400_PARAMS, sizeof(RSA_33400_PARAMS) / sizeof(RSA_33400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33500 + * @tc.name : HksRsaMtTest33500 + * @tc.desc : Test huks Verify (4096/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33500_PARAMS, sizeof(RSA_33500_PARAMS) / sizeof(RSA_33500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33600 + * @tc.name : HksRsaMtTest33600 + * @tc.desc : Test huks Verify (4096/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33600_PARAMS, sizeof(RSA_33600_PARAMS) / sizeof(RSA_33600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp new file mode 100755 index 00000000..1aa69450 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp @@ -0,0 +1,1596 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA224"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha224WithRsaMt : public testing::Test {}; + +static const struct HksParam RSA_33700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33700 + * @tc.name : HksRsaMtTest33700 + * @tc.desc : Test huks sign (512/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest33700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33700_PARAMS, sizeof(RSA_33700_PARAMS) / sizeof(RSA_33700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33800 + * @tc.name : HksRsaMtTest33800 + * @tc.desc : Test huks sign (512/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest33800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33800_PARAMS, sizeof(RSA_33800_PARAMS) / sizeof(RSA_33800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_33900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest33900 + * @tc.name : HksRsaMtTest33900 + * @tc.desc : Test huks Verify (512/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest33900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_33900_PARAMS, sizeof(RSA_33900_PARAMS) / sizeof(RSA_33900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34000 + * @tc.name : HksRsaMtTest34000 + * @tc.desc : Test huks Verify (512/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34000_PARAMS, sizeof(RSA_34000_PARAMS) / sizeof(RSA_34000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34100 + * @tc.name : HksRsaMtTest34100 + * @tc.desc : Test huks sign (768/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34100_PARAMS, sizeof(RSA_34100_PARAMS) / sizeof(RSA_34100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34200 + * @tc.name : HksRsaMtTest34200 + * @tc.desc : Test huks sign (768/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34200_PARAMS, sizeof(RSA_34200_PARAMS) / sizeof(RSA_34200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34300 + * @tc.name : HksRsaMtTest34300 + * @tc.desc : Test huks Verify (768/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34300_PARAMS, sizeof(RSA_34300_PARAMS) / sizeof(RSA_34300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34400 + * @tc.name : HksRsaMtTest34400 + * @tc.desc : Test huks Verify (768/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34400_PARAMS, sizeof(RSA_34400_PARAMS) / sizeof(RSA_34400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34500 + * @tc.name : HksRsaMtTest34500 + * @tc.desc : Test huks sign (1024/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34500_PARAMS, sizeof(RSA_34500_PARAMS) / sizeof(RSA_34500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34600 + * @tc.name : HksRsaMtTest34600 + * @tc.desc : Test huks sign (1024/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34600_PARAMS, sizeof(RSA_34600_PARAMS) / sizeof(RSA_34600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34700 + * @tc.name : HksRsaMtTest34700 + * @tc.desc : Test huks Verify (1024/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34700_PARAMS, sizeof(RSA_34700_PARAMS) / sizeof(RSA_34700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34800 + * @tc.name : HksRsaMtTest34800 + * @tc.desc : Test huks Verify (1024/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34800_PARAMS, sizeof(RSA_34800_PARAMS) / sizeof(RSA_34800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_34900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest34900 + * @tc.name : HksRsaMtTest34900 + * @tc.desc : Test huks sign (2048/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_34900_PARAMS, sizeof(RSA_34900_PARAMS) / sizeof(RSA_34900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35000 + * @tc.name : HksRsaMtTest35000 + * @tc.desc : Test huks sign (2048/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35000_PARAMS, sizeof(RSA_35000_PARAMS) / sizeof(RSA_35000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35100 + * @tc.name : HksRsaMtTest35100 + * @tc.desc : Test huks Verify (2048/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35100_PARAMS, sizeof(RSA_35100_PARAMS) / sizeof(RSA_35100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35200 + * @tc.name : HksRsaMtTest35200 + * @tc.desc : Test huks Verify (2048/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35200_PARAMS, sizeof(RSA_35200_PARAMS) / sizeof(RSA_35200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35300 + * @tc.name : HksRsaMtTest35300 + * @tc.desc : Test huks sign (3072/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35300_PARAMS, sizeof(RSA_35300_PARAMS) / sizeof(RSA_35300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35400 + * @tc.name : HksRsaMtTest35400 + * @tc.desc : Test huks sign (3072/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35400_PARAMS, sizeof(RSA_35400_PARAMS) / sizeof(RSA_35400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35500 + * @tc.name : HksRsaMtTest35500 + * @tc.desc : Test huks Verify (3072/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35500_PARAMS, sizeof(RSA_35500_PARAMS) / sizeof(RSA_35500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35600 + * @tc.name : HksRsaMtTest35600 + * @tc.desc : Test huks Verify (3072/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35600_PARAMS, sizeof(RSA_35600_PARAMS) / sizeof(RSA_35600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35700 + * @tc.name : HksRsaMtTest35700 + * @tc.desc : Test huks sign (4096/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35700_PARAMS, sizeof(RSA_35700_PARAMS) / sizeof(RSA_35700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35800 + * @tc.name : HksRsaMtTest35800 + * @tc.desc : Test huks sign (4096/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35800_PARAMS, sizeof(RSA_35800_PARAMS) / sizeof(RSA_35800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_35900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest35900 + * @tc.name : HksRsaMtTest35900 + * @tc.desc : Test huks Verify (4096/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_35900_PARAMS, sizeof(RSA_35900_PARAMS) / sizeof(RSA_35900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36000 + * @tc.name : HksRsaMtTest36000 + * @tc.desc : Test huks Verify (4096/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest36000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36000_PARAMS, sizeof(RSA_36000_PARAMS) / sizeof(RSA_36000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp new file mode 100755 index 00000000..ecc66d20 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp @@ -0,0 +1,1596 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha224AndPss"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha224WithRsaPssMt : public testing::Test {}; + +static const struct HksParam RSA_36100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36100 + * @tc.name : HksRsaMtTest36100 + * @tc.desc : Test huks sign (512/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36100_PARAMS, sizeof(RSA_36100_PARAMS) / sizeof(RSA_36100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36200 + * @tc.name : HksRsaMtTest36200 + * @tc.desc : Test huks sign (512/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36200_PARAMS, sizeof(RSA_36200_PARAMS) / sizeof(RSA_36200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36300 + * @tc.name : HksRsaMtTest36300 + * @tc.desc : Test huks Verify (512/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36300_PARAMS, sizeof(RSA_36300_PARAMS) / sizeof(RSA_36300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36400 + * @tc.name : HksRsaMtTest36400 + * @tc.desc : Test huks Verify (512/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36400_PARAMS, sizeof(RSA_36400_PARAMS) / sizeof(RSA_36400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36500 + * @tc.name : HksRsaMtTest36500 + * @tc.desc : Test huks sign (768/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36500_PARAMS, sizeof(RSA_36500_PARAMS) / sizeof(RSA_36500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36600 + * @tc.name : HksRsaMtTest36600 + * @tc.desc : Test huks sign (768/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36600_PARAMS, sizeof(RSA_36600_PARAMS) / sizeof(RSA_36600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36700 + * @tc.name : HksRsaMtTest36700 + * @tc.desc : Test huks Verify (768/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36700_PARAMS, sizeof(RSA_36700_PARAMS) / sizeof(RSA_36700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36800 + * @tc.name : HksRsaMtTest36800 + * @tc.desc : Test huks Verify (768/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36800_PARAMS, sizeof(RSA_36800_PARAMS) / sizeof(RSA_36800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_36900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest36900 + * @tc.name : HksRsaMtTest36900 + * @tc.desc : Test huks sign (1024/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_36900_PARAMS, sizeof(RSA_36900_PARAMS) / sizeof(RSA_36900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37000 + * @tc.name : HksRsaMtTest37000 + * @tc.desc : Test huks sign (1024/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37000_PARAMS, sizeof(RSA_37000_PARAMS) / sizeof(RSA_37000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37100 + * @tc.name : HksRsaMtTest37100 + * @tc.desc : Test huks Verify (1024/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37100_PARAMS, sizeof(RSA_37100_PARAMS) / sizeof(RSA_37100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37200 + * @tc.name : HksRsaMtTest37200 + * @tc.desc : Test huks Verify (1024/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37200_PARAMS, sizeof(RSA_37200_PARAMS) / sizeof(RSA_37200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37300 + * @tc.name : HksRsaMtTest37300 + * @tc.desc : Test huks sign (2048/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37300_PARAMS, sizeof(RSA_37300_PARAMS) / sizeof(RSA_37300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37400 + * @tc.name : HksRsaMtTest37400 + * @tc.desc : Test huks sign (2048/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37400_PARAMS, sizeof(RSA_37400_PARAMS) / sizeof(RSA_37400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37500 + * @tc.name : HksRsaMtTest37500 + * @tc.desc : Test huks Verify (2048/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37500_PARAMS, sizeof(RSA_37500_PARAMS) / sizeof(RSA_37500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37600 + * @tc.name : HksRsaMtTest37600 + * @tc.desc : Test huks Verify (2048/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37600_PARAMS, sizeof(RSA_37600_PARAMS) / sizeof(RSA_37600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37700 + * @tc.name : HksRsaMtTest37700 + * @tc.desc : Test huks sign (3072/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37700_PARAMS, sizeof(RSA_37700_PARAMS) / sizeof(RSA_37700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37800 + * @tc.name : HksRsaMtTest37800 + * @tc.desc : Test huks sign (3072/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37800_PARAMS, sizeof(RSA_37800_PARAMS) / sizeof(RSA_37800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_37900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest37900 + * @tc.name : HksRsaMtTest37900 + * @tc.desc : Test huks Verify (3072/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_37900_PARAMS, sizeof(RSA_37900_PARAMS) / sizeof(RSA_37900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38000 + * @tc.name : HksRsaMtTest38000 + * @tc.desc : Test huks Verify (3072/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38000_PARAMS, sizeof(RSA_38000_PARAMS) / sizeof(RSA_38000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38100 + * @tc.name : HksRsaMtTest38100 + * @tc.desc : Test huks sign (4096/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38100_PARAMS, sizeof(RSA_38100_PARAMS) / sizeof(RSA_38100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38200 + * @tc.name : HksRsaMtTest38200 + * @tc.desc : Test huks sign (4096/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38200_PARAMS, sizeof(RSA_38200_PARAMS) / sizeof(RSA_38200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38300 + * @tc.name : HksRsaMtTest38300 + * @tc.desc : Test huks Verify (4096/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38300_PARAMS, sizeof(RSA_38300_PARAMS) / sizeof(RSA_38300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38400 + * @tc.name : HksRsaMtTest38400 + * @tc.desc : Test huks Verify (4096/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38400_PARAMS, sizeof(RSA_38400_PARAMS) / sizeof(RSA_38400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp new file mode 100755 index 00000000..16887d62 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp @@ -0,0 +1,1596 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA256"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha256WithRsaMt : public testing::Test {}; + +static const struct HksParam RSA_38500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38500 + * @tc.name : HksRsaMtTest38500 + * @tc.desc : Test huks sign (512/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38500_PARAMS, sizeof(RSA_38500_PARAMS) / sizeof(RSA_38500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38600 + * @tc.name : HksRsaMtTest38600 + * @tc.desc : Test huks sign (512/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38600_PARAMS, sizeof(RSA_38600_PARAMS) / sizeof(RSA_38600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38700 + * @tc.name : HksRsaMtTest38700 + * @tc.desc : Test huks Verify (512/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38700_PARAMS, sizeof(RSA_38700_PARAMS) / sizeof(RSA_38700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38800 + * @tc.name : HksRsaMtTest38800 + * @tc.desc : Test huks Verify (512/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38800_PARAMS, sizeof(RSA_38800_PARAMS) / sizeof(RSA_38800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_38900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest38900 + * @tc.name : HksRsaMtTest38900 + * @tc.desc : Test huks sign (768/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_38900_PARAMS, sizeof(RSA_38900_PARAMS) / sizeof(RSA_38900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39000 + * @tc.name : HksRsaMtTest39000 + * @tc.desc : Test huks sign (768/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39000_PARAMS, sizeof(RSA_39000_PARAMS) / sizeof(RSA_39000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39100 + * @tc.name : HksRsaMtTest39100 + * @tc.desc : Test huks Verify (768/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39100_PARAMS, sizeof(RSA_39100_PARAMS) / sizeof(RSA_39100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39200 + * @tc.name : HksRsaMtTest39200 + * @tc.desc : Test huks Verify (768/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39200_PARAMS, sizeof(RSA_39200_PARAMS) / sizeof(RSA_39200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39300 + * @tc.name : HksRsaMtTest39300 + * @tc.desc : Test huks sign (1024/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39300_PARAMS, sizeof(RSA_39300_PARAMS) / sizeof(RSA_39300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39400 + * @tc.name : HksRsaMtTest39400 + * @tc.desc : Test huks sign (1024/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39400_PARAMS, sizeof(RSA_39400_PARAMS) / sizeof(RSA_39400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39500 + * @tc.name : HksRsaMtTest39500 + * @tc.desc : Test huks Verify (1024/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39500_PARAMS, sizeof(RSA_39500_PARAMS) / sizeof(RSA_39500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39600 + * @tc.name : HksRsaMtTest39600 + * @tc.desc : Test huks Verify (1024/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39600_PARAMS, sizeof(RSA_39600_PARAMS) / sizeof(RSA_39600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39700 + * @tc.name : HksRsaMtTest39700 + * @tc.desc : Test huks sign (2048/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39700_PARAMS, sizeof(RSA_39700_PARAMS) / sizeof(RSA_39700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39800 + * @tc.name : HksRsaMtTest39800 + * @tc.desc : Test huks sign (2048/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39800_PARAMS, sizeof(RSA_39800_PARAMS) / sizeof(RSA_39800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_39900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest39900 + * @tc.name : HksRsaMtTest39900 + * @tc.desc : Test huks Verify (2048/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_39900_PARAMS, sizeof(RSA_39900_PARAMS) / sizeof(RSA_39900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40000 + * @tc.name : HksRsaMtTest40000 + * @tc.desc : Test huks Verify (2048/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40000_PARAMS, sizeof(RSA_40000_PARAMS) / sizeof(RSA_40000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40100 + * @tc.name : HksRsaMtTest40100 + * @tc.desc : Test huks sign (3072/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40100_PARAMS, sizeof(RSA_40100_PARAMS) / sizeof(RSA_40100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40200 + * @tc.name : HksRsaMtTest40200 + * @tc.desc : Test huks sign (3072/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40200_PARAMS, sizeof(RSA_40200_PARAMS) / sizeof(RSA_40200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40300 + * @tc.name : HksRsaMtTest40300 + * @tc.desc : Test huks Verify (3072/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40300_PARAMS, sizeof(RSA_40300_PARAMS) / sizeof(RSA_40300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40400 + * @tc.name : HksRsaMtTest40400 + * @tc.desc : Test huks Verify (3072/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40400_PARAMS, sizeof(RSA_40400_PARAMS) / sizeof(RSA_40400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40500 + * @tc.name : HksRsaMtTest40500 + * @tc.desc : Test huks sign (4096/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40500_PARAMS, sizeof(RSA_40500_PARAMS) / sizeof(RSA_40500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40600 + * @tc.name : HksRsaMtTest40600 + * @tc.desc : Test huks sign (4096/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40600_PARAMS, sizeof(RSA_40600_PARAMS) / sizeof(RSA_40600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40700 + * @tc.name : HksRsaMtTest40700 + * @tc.desc : Test huks Verify (4096/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40700_PARAMS, sizeof(RSA_40700_PARAMS) / sizeof(RSA_40700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_40800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40800 + * @tc.name : HksRsaMtTest40800 + * @tc.desc : Test huks Verify (4096/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40800_PARAMS, sizeof(RSA_40800_PARAMS) / sizeof(RSA_40800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp new file mode 100755 index 00000000..52460a0c --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp @@ -0,0 +1,1596 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha256AndPss"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha256WithRsaPssMt : public testing::Test {}; + +static const struct HksParam RSA_40900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest40900 + * @tc.name : HksRsaMtTest40900 + * @tc.desc : Test huks sign (512/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest40900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_40900_PARAMS, sizeof(RSA_40900_PARAMS) / sizeof(RSA_40900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41000 + * @tc.name : HksRsaMtTest41000 + * @tc.desc : Test huks sign (512/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41000_PARAMS, sizeof(RSA_41000_PARAMS) / sizeof(RSA_41000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41100 + * @tc.name : HksRsaMtTest41100 + * @tc.desc : Test huks Verify (512/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41100_PARAMS, sizeof(RSA_41100_PARAMS) / sizeof(RSA_41100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41200 + * @tc.name : HksRsaMtTest41200 + * @tc.desc : Test huks Verify (512/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41200_PARAMS, sizeof(RSA_41200_PARAMS) / sizeof(RSA_41200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41300 + * @tc.name : HksRsaMtTest41300 + * @tc.desc : Test huks sign (768/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41300_PARAMS, sizeof(RSA_41300_PARAMS) / sizeof(RSA_41300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41400 + * @tc.name : HksRsaMtTest41400 + * @tc.desc : Test huks sign (768/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41400_PARAMS, sizeof(RSA_41400_PARAMS) / sizeof(RSA_41400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41500 + * @tc.name : HksRsaMtTest41500 + * @tc.desc : Test huks Verify (768/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41500_PARAMS, sizeof(RSA_41500_PARAMS) / sizeof(RSA_41500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41600 + * @tc.name : HksRsaMtTest41600 + * @tc.desc : Test huks Verify (768/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41600_PARAMS, sizeof(RSA_41600_PARAMS) / sizeof(RSA_41600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41700 + * @tc.name : HksRsaMtTest41700 + * @tc.desc : Test huks sign (1024/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41700_PARAMS, sizeof(RSA_41700_PARAMS) / sizeof(RSA_41700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41800 + * @tc.name : HksRsaMtTest41800 + * @tc.desc : Test huks sign (1024/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41800_PARAMS, sizeof(RSA_41800_PARAMS) / sizeof(RSA_41800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_41900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest41900 + * @tc.name : HksRsaMtTest41900 + * @tc.desc : Test huks Verify (1024/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_41900_PARAMS, sizeof(RSA_41900_PARAMS) / sizeof(RSA_41900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42000 + * @tc.name : HksRsaMtTest42000 + * @tc.desc : Test huks Verify (1024/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42000_PARAMS, sizeof(RSA_42000_PARAMS) / sizeof(RSA_42000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42100 + * @tc.name : HksRsaMtTest42100 + * @tc.desc : Test huks sign (2048/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42100_PARAMS, sizeof(RSA_42100_PARAMS) / sizeof(RSA_42100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42200 + * @tc.name : HksRsaMtTest42200 + * @tc.desc : Test huks sign (2048/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42200_PARAMS, sizeof(RSA_42200_PARAMS) / sizeof(RSA_42200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42300 + * @tc.name : HksRsaMtTest42300 + * @tc.desc : Test huks Verify (2048/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42300_PARAMS, sizeof(RSA_42300_PARAMS) / sizeof(RSA_42300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42400 + * @tc.name : HksRsaMtTest42400 + * @tc.desc : Test huks Verify (2048/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42400_PARAMS, sizeof(RSA_42400_PARAMS) / sizeof(RSA_42400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42500 + * @tc.name : HksRsaMtTest42500 + * @tc.desc : Test huks sign (3072/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42500_PARAMS, sizeof(RSA_42500_PARAMS) / sizeof(RSA_42500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42600 + * @tc.name : HksRsaMtTest42600 + * @tc.desc : Test huks sign (3072/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42600_PARAMS, sizeof(RSA_42600_PARAMS) / sizeof(RSA_42600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42700 + * @tc.name : HksRsaMtTest42700 + * @tc.desc : Test huks Verify (3072/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42700_PARAMS, sizeof(RSA_42700_PARAMS) / sizeof(RSA_42700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42800 + * @tc.name : HksRsaMtTest42800 + * @tc.desc : Test huks Verify (3072/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42800_PARAMS, sizeof(RSA_42800_PARAMS) / sizeof(RSA_42800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_42900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest42900 + * @tc.name : HksRsaMtTest42900 + * @tc.desc : Test huks sign (4096/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_42900_PARAMS, sizeof(RSA_42900_PARAMS) / sizeof(RSA_42900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43000 + * @tc.name : HksRsaMtTest43000 + * @tc.desc : Test huks sign (4096/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest43000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43000_PARAMS, sizeof(RSA_43000_PARAMS) / sizeof(RSA_43000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43100 + * @tc.name : HksRsaMtTest43100 + * @tc.desc : Test huks Verify (4096/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest43100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43100_PARAMS, sizeof(RSA_43100_PARAMS) / sizeof(RSA_43100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43200 + * @tc.name : HksRsaMtTest43200 + * @tc.desc : Test huks Verify (4096/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest43200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43200_PARAMS, sizeof(RSA_43200_PARAMS) / sizeof(RSA_43200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp new file mode 100755 index 00000000..7a8455df --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp @@ -0,0 +1,1584 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA384"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha384WithRsaMt : public testing::Test {}; + +static const struct HksParam RSA_43300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43300 + * @tc.name : HksRsaMtTest43300 + * @tc.desc : Test huks sign (512/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43300_PARAMS, sizeof(RSA_43300_PARAMS) / sizeof(RSA_43300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43400 + * @tc.name : HksRsaMtTest43400 + * @tc.desc : Test huks sign (512/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43400_PARAMS, sizeof(RSA_43400_PARAMS) / sizeof(RSA_43400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43500 + * @tc.name : HksRsaMtTest43500 + * @tc.desc : Test huks Verify (512/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43500_PARAMS, sizeof(RSA_43500_PARAMS) / sizeof(RSA_43500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); + + free(paramSetOut); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43600 + * @tc.name : HksRsaMtTest43600 + * @tc.desc : Test huks Verify (512/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43600, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43600_PARAMS, sizeof(RSA_43600_PARAMS) / sizeof(RSA_43600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + + EXPECT_EQ( + OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43700 + * @tc.name : HksRsaMtTest43700 + * @tc.desc : Test huks sign (768/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43700_PARAMS, sizeof(RSA_43700_PARAMS) / sizeof(RSA_43700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43800 + * @tc.name : HksRsaMtTest43800 + * @tc.desc : Test huks sign (768/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43800_PARAMS, sizeof(RSA_43800_PARAMS) / sizeof(RSA_43800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_43900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest43900 + * @tc.name : HksRsaMtTest43900 + * @tc.desc : Test huks Verify (768/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_43900_PARAMS, sizeof(RSA_43900_PARAMS) / sizeof(RSA_43900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44000 + * @tc.name : HksRsaMtTest44000 + * @tc.desc : Test huks Verify (768/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44000_PARAMS, sizeof(RSA_44000_PARAMS) / sizeof(RSA_44000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44100 + * @tc.name : HksRsaMtTest44100 + * @tc.desc : Test huks sign (1024/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44100_PARAMS, sizeof(RSA_44100_PARAMS) / sizeof(RSA_44100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44200 + * @tc.name : HksRsaMtTest44200 + * @tc.desc : Test huks sign (1024/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44200_PARAMS, sizeof(RSA_44200_PARAMS) / sizeof(RSA_44200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44300 + * @tc.name : HksRsaMtTest44300 + * @tc.desc : Test huks Verify (1024/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44300_PARAMS, sizeof(RSA_44300_PARAMS) / sizeof(RSA_44300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44400 + * @tc.name : HksRsaMtTest44400 + * @tc.desc : Test huks Verify (1024/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44400_PARAMS, sizeof(RSA_44400_PARAMS) / sizeof(RSA_44400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44500 + * @tc.name : HksRsaMtTest44500 + * @tc.desc : Test huks sign (2048/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44500_PARAMS, sizeof(RSA_44500_PARAMS) / sizeof(RSA_44500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44600 + * @tc.name : HksRsaMtTest44600 + * @tc.desc : Test huks sign (2048/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44600_PARAMS, sizeof(RSA_44600_PARAMS) / sizeof(RSA_44600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44700 + * @tc.name : HksRsaMtTest44700 + * @tc.desc : Test huks Verify (2048/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44700_PARAMS, sizeof(RSA_44700_PARAMS) / sizeof(RSA_44700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44800 + * @tc.name : HksRsaMtTest44800 + * @tc.desc : Test huks Verify (2048/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44800_PARAMS, sizeof(RSA_44800_PARAMS) / sizeof(RSA_44800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_44900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest44900 + * @tc.name : HksRsaMtTest44900 + * @tc.desc : Test huks sign (3072/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_44900_PARAMS, sizeof(RSA_44900_PARAMS) / sizeof(RSA_44900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45000 + * @tc.name : HksRsaMtTest45000 + * @tc.desc : Test huks sign (3072/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45000_PARAMS, sizeof(RSA_45000_PARAMS) / sizeof(RSA_45000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45100 + * @tc.name : HksRsaMtTest45100 + * @tc.desc : Test huks Verify (3072/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45100_PARAMS, sizeof(RSA_45100_PARAMS) / sizeof(RSA_45100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45200 + * @tc.name : HksRsaMtTest45200 + * @tc.desc : Test huks Verify (3072/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45200_PARAMS, sizeof(RSA_45200_PARAMS) / sizeof(RSA_45200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45300 + * @tc.name : HksRsaMtTest45300 + * @tc.desc : Test huks sign (4096/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45300_PARAMS, sizeof(RSA_45300_PARAMS) / sizeof(RSA_45300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45400 + * @tc.name : HksRsaMtTest45400 + * @tc.desc : Test huks sign (4096/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45400_PARAMS, sizeof(RSA_45400_PARAMS) / sizeof(RSA_45400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45500 + * @tc.name : HksRsaMtTest45500 + * @tc.desc : Test huks Verify (4096/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45500_PARAMS, sizeof(RSA_45500_PARAMS) / sizeof(RSA_45500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45600 + * @tc.name : HksRsaMtTest45600 + * @tc.desc : Test huks Verify (4096/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45600_PARAMS, sizeof(RSA_45600_PARAMS) / sizeof(RSA_45600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp new file mode 100755 index 00000000..54232783 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp @@ -0,0 +1,1604 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha384AndPss"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha384WithRsaPssMt : public testing::Test {}; + +static const struct HksParam RSA_45700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45700 + * @tc.name : HksRsaMtTest45700 + * @tc.desc : Test huks sign (512/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest45700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45700_PARAMS, sizeof(RSA_45700_PARAMS) / sizeof(RSA_45700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45800 + * @tc.name : HksRsaMtTest45800 + * @tc.desc : Test huks sign (512/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest45800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45800_PARAMS, sizeof(RSA_45800_PARAMS) / sizeof(RSA_45800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_45900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest45900 + * @tc.name : HksRsaMtTest45900 + * @tc.desc : Test huks Verify (512/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest45900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_45900_PARAMS, sizeof(RSA_45900_PARAMS) / sizeof(RSA_45900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46000 + * @tc.name : HksRsaMtTest46000 + * @tc.desc : Test huks Verify (512/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46000_PARAMS, sizeof(RSA_46000_PARAMS) / sizeof(RSA_46000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46100 + * @tc.name : HksRsaMtTest46100 + * @tc.desc : Test huks sign (768/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46100_PARAMS, sizeof(RSA_46100_PARAMS) / sizeof(RSA_46100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46200 + * @tc.name : HksRsaMtTest46200 + * @tc.desc : Test huks sign (768/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46200_PARAMS, sizeof(RSA_46200_PARAMS) / sizeof(RSA_46200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46300 + * @tc.name : HksRsaMtTest46300 + * @tc.desc : Test huks Verify (768/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46300_PARAMS, sizeof(RSA_46300_PARAMS) / sizeof(RSA_46300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46400 + * @tc.name : HksRsaMtTest46400 + * @tc.desc : Test huks Verify (768/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46400_PARAMS, sizeof(RSA_46400_PARAMS) / sizeof(RSA_46400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46500 + * @tc.name : HksRsaMtTest46500 + * @tc.desc : Test huks sign (1024/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46500_PARAMS, sizeof(RSA_46500_PARAMS) / sizeof(RSA_46500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46600 + * @tc.name : HksRsaMtTest46600 + * @tc.desc : Test huks sign (1024/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46600_PARAMS, sizeof(RSA_46600_PARAMS) / sizeof(RSA_46600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46700 + * @tc.name : HksRsaMtTest46700 + * @tc.desc : Test huks Verify (1024/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46700_PARAMS, sizeof(RSA_46700_PARAMS) / sizeof(RSA_46700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46800 + * @tc.name : HksRsaMtTest46800 + * @tc.desc : Test huks Verify (1024/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46800_PARAMS, sizeof(RSA_46800_PARAMS) / sizeof(RSA_46800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_46900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest46900 + * @tc.name : HksRsaMtTest46900 + * @tc.desc : Test huks sign (2048/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_46900_PARAMS, sizeof(RSA_46900_PARAMS) / sizeof(RSA_46900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47000 + * @tc.name : HksRsaMtTest47000 + * @tc.desc : Test huks sign (2048/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47000_PARAMS, sizeof(RSA_47000_PARAMS) / sizeof(RSA_47000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47100 + * @tc.name : HksRsaMtTest47100 + * @tc.desc : Test huks Verify (2048/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47100_PARAMS, sizeof(RSA_47100_PARAMS) / sizeof(RSA_47100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47200 + * @tc.name : HksRsaMtTest47200 + * @tc.desc : Test huks Verify (2048/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47200_PARAMS, sizeof(RSA_47200_PARAMS) / sizeof(RSA_47200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47300 + * @tc.name : HksRsaMtTest47300 + * @tc.desc : Test huks sign (3072/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47300_PARAMS, sizeof(RSA_47300_PARAMS) / sizeof(RSA_47300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47400 + * @tc.name : HksRsaMtTest47400 + * @tc.desc : Test huks sign (3072/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47400_PARAMS, sizeof(RSA_47400_PARAMS) / sizeof(RSA_47400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47500 + * @tc.name : HksRsaMtTest47500 + * @tc.desc : Test huks Verify (3072/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47500_PARAMS, sizeof(RSA_47500_PARAMS) / sizeof(RSA_47500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47600 + * @tc.name : HksRsaMtTest47600 + * @tc.desc : Test huks Verify (3072/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47600_PARAMS, sizeof(RSA_47600_PARAMS) / sizeof(RSA_47600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47700 + * @tc.name : HksRsaMtTest47700 + * @tc.desc : Test huks sign (4096/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47700_PARAMS, sizeof(RSA_47700_PARAMS) / sizeof(RSA_47700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47800 + * @tc.name : HksRsaMtTest47800 + * @tc.desc : Test huks sign (4096/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47800_PARAMS, sizeof(RSA_47800_PARAMS) / sizeof(RSA_47800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_47900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest47900 + * @tc.name : HksRsaMtTest47900 + * @tc.desc : Test huks Verify (4096/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_47900_PARAMS, sizeof(RSA_47900_PARAMS) / sizeof(RSA_47900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48000 + * @tc.name : HksRsaMtTest48000 + * @tc.desc : Test huks Verify (4096/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest48000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48000_PARAMS, sizeof(RSA_48000_PARAMS) / sizeof(RSA_48000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp new file mode 100755 index 00000000..70844fea --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp @@ -0,0 +1,1584 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA512"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha512WithRsaMt : public testing::Test {}; + +static const struct HksParam RSA_48100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48100 + * @tc.name : HksRsaMtTest48100 + * @tc.desc : Test huks sign (512/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48100_PARAMS, sizeof(RSA_48100_PARAMS) / sizeof(RSA_48100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48200 + * @tc.name : HksRsaMtTest48200 + * @tc.desc : Test huks sign (512/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48200_PARAMS, sizeof(RSA_48200_PARAMS) / sizeof(RSA_48200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48300 + * @tc.name : HksRsaMtTest48300 + * @tc.desc : Test huks Verify (512/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48300_PARAMS, sizeof(RSA_48300_PARAMS) / sizeof(RSA_48300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); + + free(paramSetOut); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48400 + * @tc.name : HksRsaMtTest48400 + * @tc.desc : Test huks Verify (512/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48400, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48400_PARAMS, sizeof(RSA_48400_PARAMS) / sizeof(RSA_48400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + + EXPECT_EQ( + OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48500 + * @tc.name : HksRsaMtTest48500 + * @tc.desc : Test huks sign (768/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48500_PARAMS, sizeof(RSA_48500_PARAMS) / sizeof(RSA_48500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48600 + * @tc.name : HksRsaMtTest48600 + * @tc.desc : Test huks sign (768/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48600_PARAMS, sizeof(RSA_48600_PARAMS) / sizeof(RSA_48600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48700 + * @tc.name : HksRsaMtTest48700 + * @tc.desc : Test huks Verify (768/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48700_PARAMS, sizeof(RSA_48700_PARAMS) / sizeof(RSA_48700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48800 + * @tc.name : HksRsaMtTest48800 + * @tc.desc : Test huks Verify (768/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48800_PARAMS, sizeof(RSA_48800_PARAMS) / sizeof(RSA_48800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_48900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest48900 + * @tc.name : HksRsaMtTest48900 + * @tc.desc : Test huks sign (1024/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_48900_PARAMS, sizeof(RSA_48900_PARAMS) / sizeof(RSA_48900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49000 + * @tc.name : HksRsaMtTest49000 + * @tc.desc : Test huks sign (1024/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49000_PARAMS, sizeof(RSA_49000_PARAMS) / sizeof(RSA_49000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49100 + * @tc.name : HksRsaMtTest49100 + * @tc.desc : Test huks Verify (1024/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49100_PARAMS, sizeof(RSA_49100_PARAMS) / sizeof(RSA_49100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49200 + * @tc.name : HksRsaMtTest49200 + * @tc.desc : Test huks Verify (1024/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49200_PARAMS, sizeof(RSA_49200_PARAMS) / sizeof(RSA_49200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49300 + * @tc.name : HksRsaMtTest49300 + * @tc.desc : Test huks sign (2048/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49300_PARAMS, sizeof(RSA_49300_PARAMS) / sizeof(RSA_49300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49400 + * @tc.name : HksRsaMtTest49400 + * @tc.desc : Test huks sign (2048/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49400_PARAMS, sizeof(RSA_49400_PARAMS) / sizeof(RSA_49400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49500 + * @tc.name : HksRsaMtTest49500 + * @tc.desc : Test huks Verify (2048/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49500_PARAMS, sizeof(RSA_49500_PARAMS) / sizeof(RSA_49500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49600 + * @tc.name : HksRsaMtTest49600 + * @tc.desc : Test huks Verify (2048/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49600_PARAMS, sizeof(RSA_49600_PARAMS) / sizeof(RSA_49600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49700 + * @tc.name : HksRsaMtTest49700 + * @tc.desc : Test huks sign (3072/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49700_PARAMS, sizeof(RSA_49700_PARAMS) / sizeof(RSA_49700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49800 + * @tc.name : HksRsaMtTest49800 + * @tc.desc : Test huks sign (3072/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49800_PARAMS, sizeof(RSA_49800_PARAMS) / sizeof(RSA_49800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_49900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest49900 + * @tc.name : HksRsaMtTest49900 + * @tc.desc : Test huks Verify (3072/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_49900_PARAMS, sizeof(RSA_49900_PARAMS) / sizeof(RSA_49900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50000 + * @tc.name : HksRsaMtTest50000 + * @tc.desc : Test huks Verify (3072/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50000_PARAMS, sizeof(RSA_50000_PARAMS) / sizeof(RSA_50000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50100 + * @tc.name : HksRsaMtTest50100 + * @tc.desc : Test huks sign (4096/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50100_PARAMS, sizeof(RSA_50100_PARAMS) / sizeof(RSA_50100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50200 + * @tc.name : HksRsaMtTest50200 + * @tc.desc : Test huks sign (4096/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50200_PARAMS, sizeof(RSA_50200_PARAMS) / sizeof(RSA_50200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50300 + * @tc.name : HksRsaMtTest50300 + * @tc.desc : Test huks Verify (4096/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50300_PARAMS, sizeof(RSA_50300_PARAMS) / sizeof(RSA_50300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50400 + * @tc.name : HksRsaMtTest50400 + * @tc.desc : Test huks Verify (4096/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50400_PARAMS, sizeof(RSA_50400_PARAMS) / sizeof(RSA_50400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp new file mode 100755 index 00000000..ba264a99 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp @@ -0,0 +1,1592 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_openssl_rsa_test_mt.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha512AndPss"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_512 = 512; +const int KEY_SIZE_768 = 768; +const int KEY_SIZE_1024 = 1024; +const int KEY_SIZE_2048 = 2048; +const int KEY_SIZE_3072 = 3072; +} // namespace + +class HksRsaSha512WithRsaPssMt : public testing::Test {}; + +static const struct HksParam RSA_50500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50500 + * @tc.name : HksRsaMtTest50500 + * @tc.desc : Test huks sign (512/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50500_PARAMS, sizeof(RSA_50500_PARAMS) / sizeof(RSA_50500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50600 + * @tc.name : HksRsaMtTest50600 + * @tc.desc : Test huks sign (512/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50600_PARAMS, sizeof(RSA_50600_PARAMS) / sizeof(RSA_50600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50700 + * @tc.name : HksRsaMtTest50700 + * @tc.desc : Test huks Verify (512/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50700_PARAMS, sizeof(RSA_50700_PARAMS) / sizeof(RSA_50700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); + + free(paramSetOut); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50800 + * @tc.name : HksRsaMtTest50800 + * @tc.desc : Test huks Verify (512/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50800, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50800_PARAMS, sizeof(RSA_50800_PARAMS) / sizeof(RSA_50800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); + ASSERT_NE(pkey, nullptr); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), + RSA_FAILED); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_50900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest50900 + * @tc.name : HksRsaMtTest50900 + * @tc.desc : Test huks sign (768/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_50900_PARAMS, sizeof(RSA_50900_PARAMS) / sizeof(RSA_50900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51000 + * @tc.name : HksRsaMtTest51000 + * @tc.desc : Test huks sign (768/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51000_PARAMS, sizeof(RSA_51000_PARAMS) / sizeof(RSA_51000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + +#if defined(_USE_MBEDTLS_) + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); +#else + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); +#endif + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51100 + * @tc.name : HksRsaMtTest51100 + * @tc.desc : Test huks Verify (768/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51100_PARAMS, sizeof(RSA_51100_PARAMS) / sizeof(RSA_51100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51200 + * @tc.name : HksRsaMtTest51200 + * @tc.desc : Test huks Verify (768/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51200_PARAMS, sizeof(RSA_51200_PARAMS) / sizeof(RSA_51200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51300 + * @tc.name : HksRsaMtTest51300 + * @tc.desc : Test huks sign (1024/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51300_PARAMS, sizeof(RSA_51300_PARAMS) / sizeof(RSA_51300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51400 + * @tc.name : HksRsaMtTest51400 + * @tc.desc : Test huks sign (1024/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51400_PARAMS, sizeof(RSA_51400_PARAMS) / sizeof(RSA_51400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51500 + * @tc.name : HksRsaMtTest51500 + * @tc.desc : Test huks Verify (1024/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51500_PARAMS, sizeof(RSA_51500_PARAMS) / sizeof(RSA_51500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51600 + * @tc.name : HksRsaMtTest51600 + * @tc.desc : Test huks Verify (1024/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51600_PARAMS, sizeof(RSA_51600_PARAMS) / sizeof(RSA_51600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51700 + * @tc.name : HksRsaMtTest51700 + * @tc.desc : Test huks sign (2048/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51700_PARAMS, sizeof(RSA_51700_PARAMS) / sizeof(RSA_51700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51800 + * @tc.name : HksRsaMtTest51800 + * @tc.desc : Test huks sign (2048/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51800_PARAMS, sizeof(RSA_51800_PARAMS) / sizeof(RSA_51800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_51900_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest51900 + * @tc.name : HksRsaMtTest51900 + * @tc.desc : Test huks Verify (2048/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51900, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_51900_PARAMS, sizeof(RSA_51900_PARAMS) / sizeof(RSA_51900_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52000_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52000 + * @tc.name : HksRsaMtTest52000 + * @tc.desc : Test huks Verify (2048/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52000, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52000_PARAMS, sizeof(RSA_52000_PARAMS) / sizeof(RSA_52000_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52100_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52100 + * @tc.name : HksRsaMtTest52100 + * @tc.desc : Test huks sign (3072/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52100, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52100_PARAMS, sizeof(RSA_52100_PARAMS) / sizeof(RSA_52100_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52200_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52200 + * @tc.name : HksRsaMtTest52200 + * @tc.desc : Test huks sign (3072/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52200, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52200_PARAMS, sizeof(RSA_52200_PARAMS) / sizeof(RSA_52200_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52300_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52300 + * @tc.name : HksRsaMtTest52300 + * @tc.desc : Test huks Verify (3072/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52300, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52300_PARAMS, sizeof(RSA_52300_PARAMS) / sizeof(RSA_52300_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52400_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52400 + * @tc.name : HksRsaMtTest52400 + * @tc.desc : Test huks Verify (3072/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52400, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52400_PARAMS, sizeof(RSA_52400_PARAMS) / sizeof(RSA_52400_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52500_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52500 + * @tc.name : HksRsaMtTest52500 + * @tc.desc : Test huks sign (4096/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52500, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52500_PARAMS, sizeof(RSA_52500_PARAMS) / sizeof(RSA_52500_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52600_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52600 + * @tc.name : HksRsaMtTest52600 + * @tc.desc : Test huks sign (4096/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52600, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52600_PARAMS, sizeof(RSA_52600_PARAMS) / sizeof(RSA_52600_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + free(paramSetOut); + free(publicKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52700_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52700 + * @tc.name : HksRsaMtTest52700 + * @tc.desc : Test huks Verify (4096/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52700, TestSize.Level1) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52700_PARAMS, sizeof(RSA_52700_PARAMS) / sizeof(RSA_52700_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); + + free(paramSetOut); + free(publicKey.data); + free(privateKey.data); + free(signData.data); + HksFreeParamSet(¶mInSet); +} + +static const struct HksParam RSA_52800_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +}; + +/** + * @tc.number : HksRsaMtTest52800 + * @tc.name : HksRsaMtTest52800 + * @tc.desc : Test huks Verify (4096/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52800, TestSize.Level1) +{ + struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, RSA_52800_PARAMS, sizeof(RSA_52800_PARAMS) / sizeof(RSA_52800_PARAMS[0])), + HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { 0, NULL }; + + EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); + + EVP_PKEY_free(pkey); + free(signData.data); + free(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace \ No newline at end of file diff --git a/interfaces/kits/js/@ohos.security.huks.d.ts b/interfaces/kits/js/@ohos.security.huks.d.ts index c546a7cf..9d2af17b 100755 --- a/interfaces/kits/js/@ohos.security.huks.d.ts +++ b/interfaces/kits/js/@ohos.security.huks.d.ts @@ -46,8 +46,9 @@ declare namespace huks { function sign(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; function sign(keyAlias: string, options: HksOptions) : Promise; - function verify(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; - function verify(keyAlias: string, options: HksOptions) : Promise; + function verify( + keyAlias: string, options: HksOptions, signature: Uint8Array, callback: AsyncCallback) : void; + function verify(keyAlias: string, options: HksOptions, signature: Uint8Array) : Promise; function agreeKey(keyAlias: string, options: HksOptions, callback: AsyncCallback) : void; function agreeKey(keyAlias: string, options: HksOptions) : Promise; @@ -84,6 +85,7 @@ declare namespace huks { errorCode: number; outData?: Uint8Array; properties?: Array; + certChains?: Array; } export enum HksErrorCode { @@ -191,6 +193,7 @@ declare namespace huks { HKS_KEY_PURPOSE_WRAP = 32, /* Usable with wrap key. */ HKS_KEY_PURPOSE_UNWRAP = 64, /* Usable with unwrap key. */ HKS_KEY_PURPOSE_MAC = 128, /* Usable with mac. */ + HKS_KEY_PURPOSE_AGREE = 256, /* Usable with agree. */ } export enum HksKeyDigest { @@ -240,6 +243,10 @@ declare namespace huks { HKS_AES_KEY_SIZE_512 = 512, HKS_CURVE25519_KEY_SIZE_256 = 256, + + HKS_DH_KEY_SIZE_2048 = 2048, + HKS_DH_KEY_SIZE_3072 = 3072, + HKS_DH_KEY_SIZE_4096 = 4096, } export enum HksKeyAlg { diff --git a/interfaces/kits/napi/BUILD.gn b/interfaces/kits/napi/BUILD.gn index 752b83ef..6fddff86 100755 --- a/interfaces/kits/napi/BUILD.gn +++ b/interfaces/kits/napi/BUILD.gn @@ -31,16 +31,25 @@ ohos_shared_library("huks") { sources = [ "src/huks_napi.cpp", + "src/huks_napi_agree_key.cpp", + "src/huks_napi_attest_key.cpp", "src/huks_napi_common.cpp", "src/huks_napi_decrypt.cpp", "src/huks_napi_delete_key.cpp", + "src/huks_napi_derive_key.cpp", "src/huks_napi_encrypt.cpp", "src/huks_napi_export_key.cpp", "src/huks_napi_generate_key.cpp", + "src/huks_napi_get_certificate_chain.cpp", "src/huks_napi_get_key_properties.cpp", "src/huks_napi_get_sdk_version.cpp", "src/huks_napi_import_key.cpp", "src/huks_napi_is_key_exist.cpp", + "src/huks_napi_mac.cpp", + "src/huks_napi_sign.cpp", + "src/huks_napi_unwrap_key.cpp", + "src/huks_napi_verify.cpp", + "src/huks_napi_wrap_key.cpp", ] deps = [ "//foundation/ace/napi:ace_napi" ] diff --git a/interfaces/kits/napi/include/huks_napi_agree_key.h b/interfaces/kits/napi/include/huks_napi_agree_key.h new file mode 100755 index 00000000..6704791c --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_agree_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_AGREE_KEY_H +#define HUKS_NAPI_AGREE_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiAgreeKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_AGREE_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_attest_key.h b/interfaces/kits/napi/include/huks_napi_attest_key.h new file mode 100755 index 00000000..be7074c1 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_attest_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_ATTEST_KEY_H +#define HUKS_NAPI_ATTEST_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiAttestKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_ATTEST_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_common.h b/interfaces/kits/napi/include/huks_napi_common.h index 0ac6da0a..7c9f4d35 100755 --- a/interfaces/kits/napi/include/huks_napi_common.h +++ b/interfaces/kits/napi/include/huks_napi_common.h @@ -34,6 +34,7 @@ static const std::string HKS_PARAM_PROPERTY_VALUE = "value"; static const std::string HKS_RESULT_PROPERTY_ERRORCODE = "errorCode"; static const std::string HKS_RESULT_PROPERTY_OUTDATA = "outData"; static const std::string HKS_RESULT_PRPPERTY_PROPERTIES = "properties"; +static const std::string HKS_RESULT_PRPPERTY_CERTCHAINS = "certChains"; static const std::string BUSINESS_ERROR_PROPERTY_CODE = "code"; @@ -45,8 +46,11 @@ napi_value ParseHksParamSet(napi_env env, napi_value object, HksParamSet *¶m napi_ref GetCallback(napi_env env, napi_value object); -napi_value GenerateHksResult( - napi_env env, int32_t error, uint8_t *data = nullptr, uint32_t size = 0, const HksParamSet *paramSet = nullptr); +napi_value GenerateHksResult(napi_env env, int32_t error); +napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size); +napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size, const HksParamSet ¶mSet); + +napi_value GenerateStringArray(napi_env env, const struct HksBlob *blob, const uint32_t blobCount); void CallAsyncCallback(napi_env env, napi_ref callback, int32_t error, napi_value data); @@ -79,6 +83,8 @@ inline void FreeHksBlob(HksBlob *&blob) HksFree(blob); blob = nullptr; } + +void FreeHksCertChain(HksCertChain *&certChain); } // namespace HuksNapi #endif \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_delete_key.h b/interfaces/kits/napi/include/huks_napi_delete_key.h index 77d574ab..f5f5f165 100755 --- a/interfaces/kits/napi/include/huks_napi_delete_key.h +++ b/interfaces/kits/napi/include/huks_napi_delete_key.h @@ -23,4 +23,4 @@ namespace HuksNapi { napi_value HuksNapiDeleteKey(napi_env env, napi_callback_info info); } // namespace HuksNapi -#endif // HUKS_NAPI_DELETE_KEY_H \ No newline at end of file +#endif // HUKS_NAPI_DELETE_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_derive_key.h b/interfaces/kits/napi/include/huks_napi_derive_key.h new file mode 100755 index 00000000..44482bae --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_derive_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_DERIVE_KEY_H +#define HUKS_NAPI_DERIVE_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiDeriveKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_DERIVE_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_encrypt.h b/interfaces/kits/napi/include/huks_napi_encrypt.h index 0748ca92..6f81b62d 100755 --- a/interfaces/kits/napi/include/huks_napi_encrypt.h +++ b/interfaces/kits/napi/include/huks_napi_encrypt.h @@ -23,4 +23,4 @@ namespace HuksNapi { napi_value HuksNapiEncrypt(napi_env env, napi_callback_info info); } // namespace HuksNapi -#endif // HUKS_NAPI_ENCRYPT_H \ No newline at end of file +#endif // HUKS_NAPI_ENCRYPT_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_export_key.h b/interfaces/kits/napi/include/huks_napi_export_key.h index 686ff1a8..51678621 100755 --- a/interfaces/kits/napi/include/huks_napi_export_key.h +++ b/interfaces/kits/napi/include/huks_napi_export_key.h @@ -23,4 +23,4 @@ namespace HuksNapi { napi_value HuksNapiExportKey(napi_env env, napi_callback_info info); } // namespace HuksNapi -#endif // HUKS_NAPI_EXPORT_KEY_H \ No newline at end of file +#endif // HUKS_NAPI_EXPORT_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_get_certificate_chain.h b/interfaces/kits/napi/include/huks_napi_get_certificate_chain.h new file mode 100755 index 00000000..2bb789a8 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_get_certificate_chain.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_GET_CERTIFICATE_CHAIN_H +#define HUKS_NAPI_GET_CERTIFICATE_CHAIN_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiGetCertificateChain(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_GET_CERTIFICATE_CHAIN_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_import_key.h b/interfaces/kits/napi/include/huks_napi_import_key.h index 4209aed1..5c392906 100755 --- a/interfaces/kits/napi/include/huks_napi_import_key.h +++ b/interfaces/kits/napi/include/huks_napi_import_key.h @@ -23,4 +23,4 @@ namespace HuksNapi { napi_value HuksNapiImportKey(napi_env env, napi_callback_info info); } // namespace HuksNapi -#endif // HUKS_NAPI_IMPORT_KEY_H \ No newline at end of file +#endif // HUKS_NAPI_IMPORT_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_is_key_exist.h b/interfaces/kits/napi/include/huks_napi_is_key_exist.h index b48e7f11..236512bc 100755 --- a/interfaces/kits/napi/include/huks_napi_is_key_exist.h +++ b/interfaces/kits/napi/include/huks_napi_is_key_exist.h @@ -23,4 +23,4 @@ namespace HuksNapi { napi_value HuksNapiIsKeyExist(napi_env env, napi_callback_info info); } // namespace HuksNapi -#endif // HUKS_NAPI_IS_KEY_EXIST_H \ No newline at end of file +#endif // HUKS_NAPI_IS_KEY_EXIST_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_mac.h b/interfaces/kits/napi/include/huks_napi_mac.h new file mode 100755 index 00000000..eba2f175 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_mac.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_MAC_H +#define HUKS_NAPI_MAC_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiMac(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_MAC_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_sign.h b/interfaces/kits/napi/include/huks_napi_sign.h new file mode 100755 index 00000000..4b83717f --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_sign.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_SIGN_H +#define HUKS_NAPI_SIGN_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiSign(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_SIGN_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_unwrap_key.h b/interfaces/kits/napi/include/huks_napi_unwrap_key.h new file mode 100755 index 00000000..9b0c417e --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_unwrap_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_UNWRAP_KEY_H +#define HUKS_NAPI_UNWRAP_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiUnwrapKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_UNWRAP_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_verify.h b/interfaces/kits/napi/include/huks_napi_verify.h new file mode 100755 index 00000000..1b23ddc2 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_verify.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_VERIFY_H +#define HUKS_NAPI_VERIFY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiVerify(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_VERIFY_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/huks_napi_wrap_key.h b/interfaces/kits/napi/include/huks_napi_wrap_key.h new file mode 100755 index 00000000..c9466249 --- /dev/null +++ b/interfaces/kits/napi/include/huks_napi_wrap_key.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HUKS_NAPI_WRAP_KEY_H +#define HUKS_NAPI_WRAP_KEY_H + +#include "napi/native_api.h" +#include "napi/native_node_api.h" + +namespace HuksNapi { +napi_value HuksNapiWrapKey(napi_env env, napi_callback_info info); +} // namespace HuksNapi + +#endif // HUKS_NAPI_WRAP_KEY_H \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi.cpp b/interfaces/kits/napi/src/huks_napi.cpp index bccfd571..cb631e7f 100755 --- a/interfaces/kits/napi/src/huks_napi.cpp +++ b/interfaces/kits/napi/src/huks_napi.cpp @@ -19,15 +19,24 @@ #include "napi/native_node_api.h" #include "hks_type.h" +#include "huks_napi_agree_key.h" +#include "huks_napi_attest_key.h" #include "huks_napi_decrypt.h" #include "huks_napi_delete_key.h" +#include "huks_napi_derive_key.h" #include "huks_napi_encrypt.h" #include "huks_napi_export_key.h" #include "huks_napi_generate_key.h" +#include "huks_napi_get_certificate_chain.h" #include "huks_napi_get_key_properties.h" #include "huks_napi_get_sdk_version.h" #include "huks_napi_import_key.h" #include "huks_napi_is_key_exist.h" +#include "huks_napi_mac.h" +#include "huks_napi_sign.h" +#include "huks_napi_unwrap_key.h" +#include "huks_napi_verify.h" +#include "huks_napi_wrap_key.h" namespace HuksNapi { inline void AddInt32Property(napi_env env, napi_value object, const char *name, int32_t value) @@ -188,6 +197,10 @@ static napi_value CreateHksKeySize(napi_env env) AddInt32Property(env, keySize, "HKS_CURVE25519_KEY_SIZE_256", HKS_CURVE25519_KEY_SIZE_256); + AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_2048", HKS_DH_KEY_SIZE_2048); + AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_3072", HKS_DH_KEY_SIZE_3072); + AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_4096", HKS_DH_KEY_SIZE_4096); + return keySize; } @@ -226,6 +239,7 @@ static napi_value CreateHksKeyPurpose(napi_env env) AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_WRAP", HKS_KEY_PURPOSE_WRAP); AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_UNWRAP", HKS_KEY_PURPOSE_UNWRAP); AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_MAC", HKS_KEY_PURPOSE_MAC); + AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_AGREE", HKS_KEY_PURPOSE_AGREE); return keyPurpose; } @@ -487,15 +501,15 @@ static napi_value HuksNapiRegister(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("exportKey", HuksNapiExportKey), DECLARE_NAPI_FUNCTION("getKeyProperties", HuksNapiGetKeyProperties), DECLARE_NAPI_FUNCTION("isKeyExist", HuksNapiIsKeyExist), - // DECLARE_NAPI_FUNCTION("sign", HuksNapiSign), - // DECLARE_NAPI_FUNCTION("verify", HuksNapiVerify), - // DECLARE_NAPI_FUNCTION("agreeKey", HuksNapiAgreeKey), - // DECLARE_NAPI_FUNCTION("deriveKey", HuksNapiDeriveKey), - // DECLARE_NAPI_FUNCTION("mac", HuksNapiMac), - // DECLARE_NAPI_FUNCTION("attestKey", HuksNapiAttestKey), - // DECLARE_NAPI_FUNCTION("getCertificateChain", HuksNapiGetCertificateChain), - // DECLARE_NAPI_FUNCTION("wrapKey", HuksNapiWrapKey), - // DECLARE_NAPI_FUNCTION("unwrapKey", HuksNapiUnwrapKey), + DECLARE_NAPI_FUNCTION("sign", HuksNapiSign), + DECLARE_NAPI_FUNCTION("verify", HuksNapiVerify), + DECLARE_NAPI_FUNCTION("agreeKey", HuksNapiAgreeKey), + DECLARE_NAPI_FUNCTION("deriveKey", HuksNapiDeriveKey), + DECLARE_NAPI_FUNCTION("mac", HuksNapiMac), + DECLARE_NAPI_FUNCTION("attestKey", HuksNapiAttestKey), + DECLARE_NAPI_FUNCTION("getCertificateChain", HuksNapiGetCertificateChain), + DECLARE_NAPI_FUNCTION("wrapKey", HuksNapiWrapKey), + DECLARE_NAPI_FUNCTION("unwrapKey", HuksNapiUnwrapKey), }; NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc)); return exports; diff --git a/interfaces/kits/napi/src/huks_napi_agree_key.cpp b/interfaces/kits/napi/src/huks_napi_agree_key.cpp new file mode 100755 index 00000000..4f607ce8 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_agree_key.cpp @@ -0,0 +1,247 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_agree_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_AGREE_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_AGREE_KEY_MAX_ARGS = 3; + +constexpr int HKS_MAX_AGREED_KEY_SIZE = 512; +} // namespace + +struct AgreeKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *peerPublicKey = nullptr; + struct HksBlob *agreedKey = nullptr; +}; +using AgreeKeyAsyncContext = AgreeKeyAsyncContext_t *; + +static AgreeKeyAsyncContext CreateAgreeKeyAsyncContext() +{ + AgreeKeyAsyncContext context = (AgreeKeyAsyncContext)HksMalloc(sizeof(AgreeKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(AgreeKeyAsyncContext_t), 0, sizeof(AgreeKeyAsyncContext_t)); + } + return context; +} + +static void DeleteAgreeKeyAsyncContext(napi_env env, AgreeKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->peerPublicKey != nullptr) { + if (context->peerPublicKey->data != nullptr && context->peerPublicKey->size != 0) { + (void)memset_s(context->peerPublicKey->data, context->peerPublicKey->size, 0, context->peerPublicKey->size); + } + FreeHksBlob(context->peerPublicKey); + } + + if (context->agreedKey != nullptr) { + if (context->agreedKey->data != nullptr && context->agreedKey->size != 0) { + (void)memset_s(context->agreedKey->data, context->agreedKey->size, 0, context->agreedKey->size); + } + FreeHksBlob(context->agreedKey); + } + + HksFree(context); +} + +static napi_value AgreeKeyParseParams(napi_env env, napi_callback_info info, AgreeKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_AGREE_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_AGREE_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_AGREE_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->peerPublicKey = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->peerPublicKey == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->peerPublicKey); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value AgreeKeyWriteResult(napi_env env, AgreeKeyAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->agreedKey != nullptr) ? context->agreedKey->data : nullptr), + (context->result == HKS_SUCCESS && context->agreedKey != nullptr) ? context->agreedKey->size : 0); +} + +static napi_value AgreeKeyAsyncWork(napi_env env, AgreeKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "agreeKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + AgreeKeyAsyncContext context = static_cast(data); + + context->agreedKey = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->agreedKey != nullptr) { + context->agreedKey->data = (uint8_t *)HksMalloc(HKS_MAX_AGREED_KEY_SIZE); + context->agreedKey->size = HKS_MAX_AGREED_KEY_SIZE; + } + + context->result = + HksAgreeKey(context->paramSet, context->keyAlias, context->peerPublicKey, context->agreedKey); + }, + [](napi_env env, napi_status status, void *data) { + AgreeKeyAsyncContext context = static_cast(data); + napi_value result = AgreeKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteAgreeKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteAgreeKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiAgreeKey(napi_env env, napi_callback_info info) +{ + AgreeKeyAsyncContext context = CreateAgreeKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = AgreeKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteAgreeKeyAsyncContext(env, context); + return nullptr; + } + + result = AgreeKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteAgreeKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_attest_key.cpp b/interfaces/kits/napi/src/huks_napi_attest_key.cpp new file mode 100755 index 00000000..022fcf54 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_attest_key.cpp @@ -0,0 +1,219 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_attest_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_ATTEST_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_ATTEST_KEY_MAX_ARGS = 3; +} // namespace + +struct AttestKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksCertChain *certChain = nullptr; +}; +using AttestKeyAsyncContext = AttestKeyAsyncContext_t *; + +static AttestKeyAsyncContext CreateAttestKeyAsyncContext() +{ + AttestKeyAsyncContext context = (AttestKeyAsyncContext)HksMalloc(sizeof(AttestKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(AttestKeyAsyncContext_t), 0, sizeof(AttestKeyAsyncContext_t)); + } + return context; +} + +static void DeleteAttestKeyAsyncContext(napi_env env, AttestKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->certChain != nullptr) { + FreeHksCertChain(context->certChain); + } + + HksFree(context); +} + +static napi_value AttestKeyParseParams(napi_env env, napi_callback_info info, AttestKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_ATTEST_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_ATTEST_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_ATTEST_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value AttestKeyWriteResult(napi_env env, AttestKeyAsyncContext context) +{ + napi_value result = GenerateHksResult(env, context->result, nullptr, 0); + if (result != nullptr) { + napi_value certChains = GenerateStringArray(env, context->certChain->certs, context->certChain->certsCount); + if (certChains != nullptr) { + napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_CERTCHAINS.c_str(), certChains); + } + } + return result; +} + +static napi_value AttestKeyAsyncWork(napi_env env, AttestKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "attestKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + AttestKeyAsyncContext context = static_cast(data); + + context->certChain = (struct HksCertChain *)HksMalloc(sizeof(struct HksCertChain)); + if (context->certChain != nullptr) { + context->certChain->certs = nullptr; + context->certChain->certsCount = 0; + } + + context->result = HksAttestKey(context->keyAlias, context->paramSet, context->certChain); + }, + [](napi_env env, napi_status status, void *data) { + AttestKeyAsyncContext context = static_cast(data); + napi_value result = AttestKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteAttestKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteAttestKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiAttestKey(napi_env env, napi_callback_info info) +{ + AttestKeyAsyncContext context = CreateAttestKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = AttestKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteAttestKeyAsyncContext(env, context); + return nullptr; + } + + result = AttestKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteAttestKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_common.cpp b/interfaces/kits/napi/src/huks_napi_common.cpp index abbd3c85..ca77caff 100755 --- a/interfaces/kits/napi/src/huks_napi_common.cpp +++ b/interfaces/kits/napi/src/huks_napi_common.cpp @@ -75,8 +75,13 @@ napi_value GetUint8Array(napi_env env, napi_value object, HksBlob &arrayBlob) HKS_LOG_E("data len is too large, len = %x", length); return nullptr; } + + arrayBlob.data = (uint8_t *)HksMalloc(length); + if (arrayBlob.data == nullptr) { + return nullptr; + } + (void)memcpy_s(arrayBlob.data, length, rawData, length); arrayBlob.size = (uint32_t)length; - arrayBlob.data = (uint8_t *)rawData; return GetInt32(env, 0); } @@ -208,31 +213,31 @@ static napi_value GenerateAarrayBuffer(napi_env env, uint8_t *data, uint32_t siz return outBuffer; } -static napi_value GenerateHksParam(napi_env env, const HksParam *param) +static napi_value GenerateHksParam(napi_env env, const HksParam ¶m) { napi_value hksParam = nullptr; NAPI_CALL(env, napi_create_object(env, &hksParam)); napi_value tag = nullptr; - NAPI_CALL(env, napi_create_uint32(env, param->tag, &tag)); + NAPI_CALL(env, napi_create_uint32(env, param.tag, &tag)); NAPI_CALL(env, napi_set_named_property(env, hksParam, HKS_PARAM_PROPERTY_TAG.c_str(), tag)); napi_value value = nullptr; - switch (param->tag & HKS_TAG_TYPE_MASK) { + switch (param.tag & HKS_TAG_TYPE_MASK) { case HKS_TAG_TYPE_INT: - NAPI_CALL(env, napi_create_int32(env, param->int32Param, &value)); + NAPI_CALL(env, napi_create_int32(env, param.int32Param, &value)); break; case HKS_TAG_TYPE_UINT: - NAPI_CALL(env, napi_create_uint32(env, param->uint32Param, &value)); + NAPI_CALL(env, napi_create_uint32(env, param.uint32Param, &value)); break; case HKS_TAG_TYPE_ULONG: - NAPI_CALL(env, napi_create_int64(env, param->uint64Param, &value)); + NAPI_CALL(env, napi_create_int64(env, param.uint64Param, &value)); break; case HKS_TAG_TYPE_BOOL: - NAPI_CALL(env, napi_get_boolean(env, param->boolParam, &value)); + NAPI_CALL(env, napi_get_boolean(env, param.boolParam, &value)); break; case HKS_TAG_TYPE_BYTES: - value = GenerateAarrayBuffer(env, param->blob.data, param->blob.size); + value = GenerateAarrayBuffer(env, param.blob.data, param.blob.size); break; default: value = GetNull(env); @@ -243,21 +248,39 @@ static napi_value GenerateHksParam(napi_env env, const HksParam *param) return hksParam; } -static napi_value GenerateHksParamArray(napi_env env, const HksParamSet *paramSet) +static napi_value GenerateHksParamArray(napi_env env, const HksParamSet ¶mSet) { napi_value paramArray = nullptr; NAPI_CALL(env, napi_create_array(env, ¶mArray)); - for (uint32_t i = 0; i < paramSet->paramsCnt; i++) { + for (uint32_t i = 0; i < paramSet.paramsCnt; i++) { napi_value element = nullptr; - element = GenerateHksParam(env, ¶mSet->params[i]); + element = GenerateHksParam(env, paramSet.params[i]); napi_set_element(env, paramArray, i, element); } return paramArray; } -napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size, const HksParamSet *paramSet) +napi_value GenerateHksResult(napi_env env, int32_t error) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_create_object(env, &result)); + + napi_value errorCode = nullptr; + NAPI_CALL(env, napi_create_int32(env, error, &errorCode)); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_ERRORCODE.c_str(), errorCode)); + + napi_value outData = GetNull(env); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_OUTDATA.c_str(), outData)); + + napi_value properties = GetNull(env); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_PROPERTIES.c_str(), properties)); + + return result; +} + +napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size) { napi_value result = nullptr; NAPI_CALL(env, napi_create_object(env, &result)); @@ -277,12 +300,33 @@ napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_ } NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_OUTDATA.c_str(), outData)); - napi_value properties = nullptr; - if (paramSet != nullptr) { - properties = GenerateHksParamArray(env, paramSet); + napi_value properties = GetNull(env); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_PROPERTIES.c_str(), properties)); + + return result; +} + +napi_value GenerateHksResult(napi_env env, int32_t error, uint8_t *data, uint32_t size, const HksParamSet ¶mSet) +{ + napi_value result = nullptr; + NAPI_CALL(env, napi_create_object(env, &result)); + + napi_value errorCode = nullptr; + NAPI_CALL(env, napi_create_int32(env, error, &errorCode)); + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_ERRORCODE.c_str(), errorCode)); + + napi_value outData = nullptr; + if (data != nullptr && size != 0) { + napi_value outBuffer = GenerateAarrayBuffer(env, data, size); + if (outBuffer != nullptr) { + NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, size, outBuffer, 0, &outData)); + } } else { - properties = GetNull(env); + outData = GetNull(env); } + NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PROPERTY_OUTDATA.c_str(), outData)); + + napi_value properties = GenerateHksParamArray(env, paramSet); NAPI_CALL(env, napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_PROPERTIES.c_str(), properties)); return result; @@ -304,11 +348,47 @@ void CallAsyncCallback(napi_env env, napi_ref callback, int32_t error, napi_valu { napi_value businessError = GenerateBusinessError(env, error); - napi_value params[ASYNCCALLBACK_ARGC] = {businessError, data}; + napi_value params[ASYNCCALLBACK_ARGC] = { businessError, data }; napi_value func = nullptr; NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callback, &func)); - NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, func, ASYNCCALLBACK_ARGC, params, nullptr)); + napi_value recv = nullptr; + napi_value result = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &recv)); + NAPI_CALL_RETURN_VOID(env, napi_call_function(env, recv, func, ASYNCCALLBACK_ARGC, params, &result)); +} + +napi_value GenerateStringArray(napi_env env, const struct HksBlob *blob, const uint32_t blobCount) +{ + if (blobCount == 0 || blob == nullptr) { + return nullptr; + } + napi_value array = nullptr; + NAPI_CALL(env, napi_create_array(env, &array)); + for (uint32_t i = 0; i < blobCount; i++) { + napi_value element = nullptr; + napi_create_string_latin1(env, (const char *)blob[i].data, blob[i].size, &element); + napi_set_element(env, array, i, element); + } + return array; +} + +void FreeHksCertChain(HksCertChain *&certChain) +{ + if (certChain == nullptr) { + return; + } + + if (certChain->certsCount > 0 && certChain->certs != nullptr) { + for (uint32_t i = 0; i < certChain->certsCount; i++) { + if (certChain->certs[i].data != nullptr) { + HksFree(certChain->certs[i].data); + } + } + } + + HksFree(certChain); + certChain = nullptr; } } // namespace HuksNapi \ No newline at end of file diff --git a/interfaces/kits/napi/src/huks_napi_decrypt.cpp b/interfaces/kits/napi/src/huks_napi_decrypt.cpp index 2e9f2c1a..cf0f75c8 100755 --- a/interfaces/kits/napi/src/huks_napi_decrypt.cpp +++ b/interfaces/kits/napi/src/huks_napi_decrypt.cpp @@ -30,7 +30,7 @@ constexpr int HUKS_NAPI_DECRYPT_MIN_ARGS = 2; constexpr int HUKS_NAPI_DECRYPT_MAX_ARGS = 3; } // namespace -struct DecryptAsyncContext { +struct DecryptAsyncContext_t { napi_async_work asyncWork = nullptr; napi_deferred deferred = nullptr; napi_ref callback = nullptr; @@ -41,17 +41,18 @@ struct DecryptAsyncContext { struct HksBlob *cipherText = nullptr; struct HksBlob *plainText = nullptr; }; +using DecryptAsyncContext = DecryptAsyncContext_t *; -static DecryptAsyncContext *CreateDecryptAsyncContext() +static DecryptAsyncContext CreateDecryptAsyncContext() { - DecryptAsyncContext *context = (DecryptAsyncContext *)HksMalloc(sizeof(DecryptAsyncContext)); + DecryptAsyncContext context = (DecryptAsyncContext)HksMalloc(sizeof(DecryptAsyncContext_t)); if (context != nullptr) { - (void)memset_s(context, sizeof(DecryptAsyncContext), 0, sizeof(DecryptAsyncContext)); + (void)memset_s(context, sizeof(DecryptAsyncContext_t), 0, sizeof(DecryptAsyncContext_t)); } return context; } -static void DeleteDecryptAsyncContext(napi_env env, DecryptAsyncContext *context) +static void DeleteDecryptAsyncContext(napi_env env, DecryptAsyncContext context) { if (context == nullptr) { return; @@ -92,7 +93,7 @@ static void DeleteDecryptAsyncContext(napi_env env, DecryptAsyncContext *context HksFree(context); } -static napi_value DecryptParseParams(napi_env env, napi_callback_info info, DecryptAsyncContext *context) +static napi_value DecryptParseParams(napi_env env, napi_callback_info info, DecryptAsyncContext context) { size_t argc = HUKS_NAPI_DECRYPT_MAX_ARGS; napi_value argv[HUKS_NAPI_DECRYPT_MAX_ARGS] = {0}; @@ -133,6 +134,10 @@ static napi_value DecryptParseParams(napi_env env, napi_callback_info info, Decr return nullptr; } context->cipherText = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->cipherText == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } result = GetUint8Array(env, inData, *context->cipherText); if (result == nullptr) { HKS_LOG_E("could not get indata"); @@ -147,7 +152,7 @@ static napi_value DecryptParseParams(napi_env env, napi_callback_info info, Decr return GetInt32(env, 0); } -static napi_value DecryptKeyWriteResult(napi_env env, DecryptAsyncContext *context) +static napi_value DecryptKeyWriteResult(napi_env env, DecryptAsyncContext context) { return GenerateHksResult(env, context->result, @@ -155,7 +160,7 @@ static napi_value DecryptKeyWriteResult(napi_env env, DecryptAsyncContext *conte (context->result == HKS_SUCCESS && context->plainText != nullptr) ? context->plainText->size : 0); } -static napi_value DecryptAsyncWork(napi_env env, DecryptAsyncContext *context) +static napi_value DecryptAsyncWork(napi_env env, DecryptAsyncContext context) { napi_value promise = nullptr; if (context->callback == nullptr) { @@ -170,7 +175,7 @@ static napi_value DecryptAsyncWork(napi_env env, DecryptAsyncContext *context) nullptr, resourceName, [](napi_env env, void *data) { - DecryptAsyncContext *context = static_cast(data); + DecryptAsyncContext context = static_cast(data); context->plainText = (HksBlob *)HksMalloc(sizeof(HksBlob)); if (context->plainText != NULL) { @@ -181,7 +186,7 @@ static napi_value DecryptAsyncWork(napi_env env, DecryptAsyncContext *context) context->result = HksDecrypt(context->keyAlias, context->paramSet, context->cipherText, context->plainText); }, [](napi_env env, napi_status status, void *data) { - DecryptAsyncContext *context = static_cast(data); + DecryptAsyncContext context = static_cast(data); napi_value result = DecryptKeyWriteResult(env, context); if (result == nullptr) { return; @@ -214,8 +219,7 @@ static napi_value DecryptAsyncWork(napi_env env, DecryptAsyncContext *context) napi_value HuksNapiDecrypt(napi_env env, napi_callback_info info) { - DecryptAsyncContext *context = CreateDecryptAsyncContext(); - + DecryptAsyncContext context = CreateDecryptAsyncContext(); if (context == nullptr) { HKS_LOG_E("could not create context"); return nullptr; diff --git a/interfaces/kits/napi/src/huks_napi_delete_key.cpp b/interfaces/kits/napi/src/huks_napi_delete_key.cpp index a25d0d57..93586fc2 100755 --- a/interfaces/kits/napi/src/huks_napi_delete_key.cpp +++ b/interfaces/kits/napi/src/huks_napi_delete_key.cpp @@ -30,7 +30,7 @@ constexpr int HUKS_NAPI_DELETE_KEY_MIN_ARGS = 2; constexpr int HUKS_NAPI_DELETE_KEY_MAX_ARGS = 3; } // namespace -struct DeleteKeyAsyncContext { +struct DeleteKeyAsyncContext_t { napi_async_work asyncWork = nullptr; napi_deferred deferred = nullptr; napi_ref callback = nullptr; @@ -39,17 +39,18 @@ struct DeleteKeyAsyncContext { struct HksBlob *keyAlias = nullptr; struct HksParamSet *paramSet = nullptr; }; +using DeleteKeyAsyncContext = DeleteKeyAsyncContext_t *; -static DeleteKeyAsyncContext *CreateDeleteKeyAsyncContext() +static DeleteKeyAsyncContext CreateDeleteKeyAsyncContext() { - DeleteKeyAsyncContext *context = (DeleteKeyAsyncContext *)HksMalloc(sizeof(DeleteKeyAsyncContext)); + DeleteKeyAsyncContext context = (DeleteKeyAsyncContext)HksMalloc(sizeof(DeleteKeyAsyncContext_t)); if (context != nullptr) { - (void)memset_s(context, sizeof(DeleteKeyAsyncContext), 0, sizeof(DeleteKeyAsyncContext)); + (void)memset_s(context, sizeof(DeleteKeyAsyncContext_t), 0, sizeof(DeleteKeyAsyncContext_t)); } return context; } -static void DeleteDeleteKeyAsyncContext(napi_env env, DeleteKeyAsyncContext *context) +static void DeleteDeleteKeyAsyncContext(napi_env env, DeleteKeyAsyncContext context) { if (context == nullptr) { return; @@ -76,7 +77,7 @@ static void DeleteDeleteKeyAsyncContext(napi_env env, DeleteKeyAsyncContext *con HksFree(context); } -static napi_value DeleteKeyParseParams(napi_env env, napi_callback_info info, DeleteKeyAsyncContext *context) +static napi_value DeleteKeyParseParams(napi_env env, napi_callback_info info, DeleteKeyAsyncContext context) { size_t argc = HUKS_NAPI_DELETE_KEY_MAX_ARGS; napi_value argv[HUKS_NAPI_DELETE_KEY_MAX_ARGS] = {0}; @@ -118,12 +119,12 @@ static napi_value DeleteKeyParseParams(napi_env env, napi_callback_info info, De return GetInt32(env, 0); } -static napi_value DeleteKeyWriteResult(napi_env env, DeleteKeyAsyncContext *context) +static napi_value DeleteKeyWriteResult(napi_env env, DeleteKeyAsyncContext context) { return GenerateHksResult(env, context->result, nullptr, 0); } -static napi_value DeleteKeyAsyncWork(napi_env env, DeleteKeyAsyncContext *context) +static napi_value DeleteKeyAsyncWork(napi_env env, DeleteKeyAsyncContext context) { napi_value promise = nullptr; if (context->callback == nullptr) { @@ -138,12 +139,12 @@ static napi_value DeleteKeyAsyncWork(napi_env env, DeleteKeyAsyncContext *contex nullptr, resourceName, [](napi_env env, void *data) { - DeleteKeyAsyncContext *context = static_cast(data); + DeleteKeyAsyncContext context = static_cast(data); context->result = HksDeleteKey(context->keyAlias, context->paramSet); }, [](napi_env env, napi_status status, void *data) { - DeleteKeyAsyncContext *context = static_cast(data); + DeleteKeyAsyncContext context = static_cast(data); napi_value result = DeleteKeyWriteResult(env, context); if (result == nullptr) { return; @@ -175,8 +176,7 @@ static napi_value DeleteKeyAsyncWork(napi_env env, DeleteKeyAsyncContext *contex napi_value HuksNapiDeleteKey(napi_env env, napi_callback_info info) { - DeleteKeyAsyncContext *context = CreateDeleteKeyAsyncContext(); - + DeleteKeyAsyncContext context = CreateDeleteKeyAsyncContext(); if (context == nullptr) { HKS_LOG_E("could not create context"); return nullptr; diff --git a/interfaces/kits/napi/src/huks_napi_derive_key.cpp b/interfaces/kits/napi/src/huks_napi_derive_key.cpp new file mode 100755 index 00000000..9019f847 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_derive_key.cpp @@ -0,0 +1,220 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_derive_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_DERIVE_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_DERIVE_KEY_MAX_ARGS = 3; + +constexpr int HKS_MAX_DERIVED_KEY_SIZE = 512; +} // namespace + +struct DeriveKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *derivedKey = nullptr; +}; +using DeriveKeyAsyncContext = DeriveKeyAsyncContext_t *; + +static DeriveKeyAsyncContext CreateDeriveKeyAsyncContext() +{ + DeriveKeyAsyncContext context = (DeriveKeyAsyncContext)HksMalloc(sizeof(DeriveKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(DeriveKeyAsyncContext_t), 0, sizeof(DeriveKeyAsyncContext_t)); + } + return context; +} + +static void DeleteDeriveKeyAsyncContext(napi_env env, DeriveKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->derivedKey != nullptr) { + if (context->derivedKey->data != nullptr && context->derivedKey->size != 0) { + (void)memset_s(context->derivedKey->data, context->derivedKey->size, 0, context->derivedKey->size); + } + FreeHksBlob(context->derivedKey); + } + + HksFree(context); +} + +static napi_value DeriveKeyParseParams(napi_env env, napi_callback_info info, DeriveKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_DERIVE_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_DERIVE_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_DERIVE_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value DeriveKeyWriteResult(napi_env env, DeriveKeyAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->derivedKey != nullptr) ? context->derivedKey->data : nullptr), + (context->result == HKS_SUCCESS && context->derivedKey != nullptr) ? context->derivedKey->size : 0); +} + +static napi_value DeriveKeyAsyncWork(napi_env env, DeriveKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "deriveKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + DeriveKeyAsyncContext context = static_cast(data); + + context->derivedKey = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->derivedKey != nullptr) { + context->derivedKey->data = (uint8_t *)HksMalloc(HKS_MAX_DERIVED_KEY_SIZE); + context->derivedKey->size = HKS_MAX_DERIVED_KEY_SIZE; + } + + context->result = HksDeriveKey(context->paramSet, context->keyAlias, context->derivedKey); + }, + [](napi_env env, napi_status status, void *data) { + DeriveKeyAsyncContext context = static_cast(data); + napi_value result = DeriveKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteDeriveKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteDeriveKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiDeriveKey(napi_env env, napi_callback_info info) +{ + DeriveKeyAsyncContext context = CreateDeriveKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = DeriveKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteDeriveKeyAsyncContext(env, context); + return nullptr; + } + + result = DeriveKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteDeriveKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_encrypt.cpp b/interfaces/kits/napi/src/huks_napi_encrypt.cpp index 1a489e5a..32ad0847 100755 --- a/interfaces/kits/napi/src/huks_napi_encrypt.cpp +++ b/interfaces/kits/napi/src/huks_napi_encrypt.cpp @@ -32,7 +32,7 @@ constexpr int HUKS_NAPI_ENCRYPT_MAX_ARGS = 3; constexpr int HKS_CIPHER_TEXT_DEFALT_PADDING = 512; } // namespace -struct EncryptAsyncContext { +struct EncryptAsyncContext_t { napi_async_work asyncWork = nullptr; napi_deferred deferred = nullptr; napi_ref callback = nullptr; @@ -43,17 +43,18 @@ struct EncryptAsyncContext { struct HksBlob *plainText = nullptr; struct HksBlob *cipherText = nullptr; }; +using EncryptAsyncContext = EncryptAsyncContext_t *; -static EncryptAsyncContext *CreateEncryptAsyncContext() +static EncryptAsyncContext CreateEncryptAsyncContext() { - EncryptAsyncContext *context = (EncryptAsyncContext *)HksMalloc(sizeof(EncryptAsyncContext)); + EncryptAsyncContext context = (EncryptAsyncContext)HksMalloc(sizeof(EncryptAsyncContext_t)); if (context != nullptr) { - (void)memset_s(context, sizeof(EncryptAsyncContext), 0, sizeof(EncryptAsyncContext)); + (void)memset_s(context, sizeof(EncryptAsyncContext_t), 0, sizeof(EncryptAsyncContext_t)); } return context; } -static void DeleteEncryptAsyncContext(napi_env env, EncryptAsyncContext *context) +static void DeleteEncryptAsyncContext(napi_env env, EncryptAsyncContext context) { if (context == nullptr) { return; @@ -94,7 +95,7 @@ static void DeleteEncryptAsyncContext(napi_env env, EncryptAsyncContext *context HksFree(context); } -static napi_value EncryptParseParams(napi_env env, napi_callback_info info, EncryptAsyncContext *context) +static napi_value EncryptParseParams(napi_env env, napi_callback_info info, EncryptAsyncContext context) { size_t argc = HUKS_NAPI_ENCRYPT_MAX_ARGS; napi_value argv[HUKS_NAPI_ENCRYPT_MAX_ARGS] = {0}; @@ -135,6 +136,10 @@ static napi_value EncryptParseParams(napi_env env, napi_callback_info info, Encr return nullptr; } context->plainText = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->plainText == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } result = GetUint8Array(env, inData, *context->plainText); if (result == nullptr) { HKS_LOG_E("could not get indata"); @@ -149,7 +154,7 @@ static napi_value EncryptParseParams(napi_env env, napi_callback_info info, Encr return GetInt32(env, 0); } -static napi_value EncryptKeyWriteResult(napi_env env, EncryptAsyncContext *context) +static napi_value EncryptWriteResult(napi_env env, EncryptAsyncContext context) { return GenerateHksResult(env, context->result, @@ -157,7 +162,7 @@ static napi_value EncryptKeyWriteResult(napi_env env, EncryptAsyncContext *conte (context->result == HKS_SUCCESS && context->cipherText != nullptr) ? context->cipherText->size : 0); } -static napi_value EncryptAsyncWork(napi_env env, EncryptAsyncContext *context) +static napi_value EncryptAsyncWork(napi_env env, EncryptAsyncContext context) { napi_value promise = nullptr; if (context->callback == nullptr) { @@ -172,7 +177,7 @@ static napi_value EncryptAsyncWork(napi_env env, EncryptAsyncContext *context) nullptr, resourceName, [](napi_env env, void *data) { - EncryptAsyncContext *context = static_cast(data); + EncryptAsyncContext context = static_cast(data); context->cipherText = (HksBlob *)HksMalloc(sizeof(HksBlob)); if (context->cipherText != NULL) { @@ -184,8 +189,8 @@ static napi_value EncryptAsyncWork(napi_env env, EncryptAsyncContext *context) context->result = HksEncrypt(context->keyAlias, context->paramSet, context->plainText, context->cipherText); }, [](napi_env env, napi_status status, void *data) { - EncryptAsyncContext *context = static_cast(data); - napi_value result = EncryptKeyWriteResult(env, context); + EncryptAsyncContext context = static_cast(data); + napi_value result = EncryptWriteResult(env, context); if (result == nullptr) { return; } @@ -217,8 +222,7 @@ static napi_value EncryptAsyncWork(napi_env env, EncryptAsyncContext *context) napi_value HuksNapiEncrypt(napi_env env, napi_callback_info info) { - EncryptAsyncContext *context = CreateEncryptAsyncContext(); - + EncryptAsyncContext context = CreateEncryptAsyncContext(); if (context == nullptr) { HKS_LOG_E("could not create context"); return nullptr; diff --git a/interfaces/kits/napi/src/huks_napi_export_key.cpp b/interfaces/kits/napi/src/huks_napi_export_key.cpp index f9e976ec..fb49cb11 100755 --- a/interfaces/kits/napi/src/huks_napi_export_key.cpp +++ b/interfaces/kits/napi/src/huks_napi_export_key.cpp @@ -30,7 +30,7 @@ constexpr int HUKS_NAPI_EXPORT_KEY_MIN_ARGS = 2; constexpr int HUKS_NAPI_EXPORT_KEY_MAX_ARGS = 3; } // namespace -struct ExportKeyAsyncContext { +struct ExportKeyAsyncContext_t { napi_async_work asyncWork = nullptr; napi_deferred deferred = nullptr; napi_ref callback = nullptr; @@ -40,17 +40,18 @@ struct ExportKeyAsyncContext { struct HksParamSet *paramSet = nullptr; struct HksBlob *key = nullptr; }; +using ExportKeyAsyncContext = ExportKeyAsyncContext_t *; -static ExportKeyAsyncContext *CreateExportKeyAsyncContext() +static ExportKeyAsyncContext CreateExportKeyAsyncContext() { - ExportKeyAsyncContext *context = (ExportKeyAsyncContext *)HksMalloc(sizeof(ExportKeyAsyncContext)); + ExportKeyAsyncContext context = (ExportKeyAsyncContext)HksMalloc(sizeof(ExportKeyAsyncContext_t)); if (context != nullptr) { - (void)memset_s(context, sizeof(ExportKeyAsyncContext), 0, sizeof(ExportKeyAsyncContext)); + (void)memset_s(context, sizeof(ExportKeyAsyncContext_t), 0, sizeof(ExportKeyAsyncContext_t)); } return context; } -static void DeleteExportKeyAsyncContext(napi_env env, ExportKeyAsyncContext *context) +static void DeleteExportKeyAsyncContext(napi_env env, ExportKeyAsyncContext context) { if (context == nullptr) { return; @@ -84,7 +85,7 @@ static void DeleteExportKeyAsyncContext(napi_env env, ExportKeyAsyncContext *con HksFree(context); } -static napi_value ExportKeyParseParams(napi_env env, napi_callback_info info, ExportKeyAsyncContext *context) +static napi_value ExportKeyParseParams(napi_env env, napi_callback_info info, ExportKeyAsyncContext context) { size_t argc = HUKS_NAPI_EXPORT_KEY_MAX_ARGS; napi_value argv[HUKS_NAPI_EXPORT_KEY_MAX_ARGS] = {0}; @@ -126,7 +127,7 @@ static napi_value ExportKeyParseParams(napi_env env, napi_callback_info info, Ex return GetInt32(env, 0); } -static napi_value ExportKeyWriteResult(napi_env env, ExportKeyAsyncContext *context) +static napi_value ExportKeyWriteResult(napi_env env, ExportKeyAsyncContext context) { return GenerateHksResult(env, context->result, @@ -134,7 +135,7 @@ static napi_value ExportKeyWriteResult(napi_env env, ExportKeyAsyncContext *cont (context->result == HKS_SUCCESS && context->key != nullptr) ? context->key->size : 0); } -static napi_value ExportKeyAsyncWork(napi_env env, ExportKeyAsyncContext *context) +static napi_value ExportKeyAsyncWork(napi_env env, ExportKeyAsyncContext context) { napi_value promise = nullptr; if (context->callback == nullptr) { @@ -149,7 +150,7 @@ static napi_value ExportKeyAsyncWork(napi_env env, ExportKeyAsyncContext *contex nullptr, resourceName, [](napi_env env, void *data) { - ExportKeyAsyncContext *context = static_cast(data); + ExportKeyAsyncContext context = static_cast(data); context->key = (HksBlob *)HksMalloc(sizeof(HksBlob)); if (context->key != NULL) { @@ -160,7 +161,7 @@ static napi_value ExportKeyAsyncWork(napi_env env, ExportKeyAsyncContext *contex context->result = HksExportPublicKey(context->keyAlias, context->paramSet, context->key); }, [](napi_env env, napi_status status, void *data) { - ExportKeyAsyncContext *context = static_cast(data); + ExportKeyAsyncContext context = static_cast(data); napi_value result = ExportKeyWriteResult(env, context); if (result == nullptr) { return; @@ -192,8 +193,7 @@ static napi_value ExportKeyAsyncWork(napi_env env, ExportKeyAsyncContext *contex napi_value HuksNapiExportKey(napi_env env, napi_callback_info info) { - ExportKeyAsyncContext *context = CreateExportKeyAsyncContext(); - + ExportKeyAsyncContext context = CreateExportKeyAsyncContext(); if (context == nullptr) { HKS_LOG_E("could not create context"); return nullptr; diff --git a/interfaces/kits/napi/src/huks_napi_generate_key.cpp b/interfaces/kits/napi/src/huks_napi_generate_key.cpp index 2184950a..c50828d4 100755 --- a/interfaces/kits/napi/src/huks_napi_generate_key.cpp +++ b/interfaces/kits/napi/src/huks_napi_generate_key.cpp @@ -30,7 +30,7 @@ constexpr int HUKS_NAPI_GETNRATEKEY_MIN_ARGS = 2; constexpr int HUKS_NAPI_GENERATEKEY_MAX_ARGS = 3; } // namespace -struct GenerateKeyAsyncContext { +struct GenerateKeyAsyncContext_t { napi_async_work asyncWork = nullptr; napi_deferred deferred = nullptr; napi_ref callback = nullptr; @@ -40,17 +40,18 @@ struct GenerateKeyAsyncContext { struct HksParamSet *paramSetIn = nullptr; struct HksParamSet *paramSetOut = nullptr; }; +using GenerateKeyAsyncContext = GenerateKeyAsyncContext_t *; -static GenerateKeyAsyncContext *CreateGenerateKeyAsyncContext() +static GenerateKeyAsyncContext CreateGenerateKeyAsyncContext() { - GenerateKeyAsyncContext *context = (GenerateKeyAsyncContext *)HksMalloc(sizeof(GenerateKeyAsyncContext)); + GenerateKeyAsyncContext context = (GenerateKeyAsyncContext)HksMalloc(sizeof(GenerateKeyAsyncContext_t)); if (context != nullptr) { - (void)memset_s(context, sizeof(GenerateKeyAsyncContext), 0, sizeof(GenerateKeyAsyncContext)); + (void)memset_s(context, sizeof(GenerateKeyAsyncContext_t), 0, sizeof(GenerateKeyAsyncContext_t)); } return context; } -static void DeleteGenerateKeyAsyncContext(napi_env env, GenerateKeyAsyncContext *context) +static void DeleteGenerateKeyAsyncContext(napi_env env, GenerateKeyAsyncContext context) { if (context == nullptr) { return; @@ -81,7 +82,7 @@ static void DeleteGenerateKeyAsyncContext(napi_env env, GenerateKeyAsyncContext HksFree(context); } -static napi_value GenerateKeyParseParams(napi_env env, napi_callback_info info, GenerateKeyAsyncContext *context) +static napi_value GenerateKeyParseParams(napi_env env, napi_callback_info info, GenerateKeyAsyncContext context) { size_t argc = HUKS_NAPI_GENERATEKEY_MAX_ARGS; napi_value argv[HUKS_NAPI_GENERATEKEY_MAX_ARGS] = {0}; @@ -123,12 +124,12 @@ static napi_value GenerateKeyParseParams(napi_env env, napi_callback_info info, return GetInt32(env, 0); } -static napi_value GenerateKeyWriteResult(napi_env env, GenerateKeyAsyncContext *context) +static napi_value GenerateKeyWriteResult(napi_env env, GenerateKeyAsyncContext context) { return GenerateHksResult(env, context->result, nullptr, 0); } -static napi_value GenerateKeyAsyncWork(napi_env env, GenerateKeyAsyncContext *context) +static napi_value GenerateKeyAsyncWork(napi_env env, GenerateKeyAsyncContext context) { napi_value promise = nullptr; if (context->callback == nullptr) { @@ -143,12 +144,12 @@ static napi_value GenerateKeyAsyncWork(napi_env env, GenerateKeyAsyncContext *co nullptr, resourceName, [](napi_env env, void *data) { - GenerateKeyAsyncContext *context = static_cast(data); + GenerateKeyAsyncContext context = static_cast(data); context->result = HksGenerateKey(context->keyAlias, context->paramSetIn, context->paramSetOut); }, [](napi_env env, napi_status status, void *data) { - GenerateKeyAsyncContext *context = static_cast(data); + GenerateKeyAsyncContext context = static_cast(data); napi_value result = GenerateKeyWriteResult(env, context); if (result == nullptr) { return; @@ -180,8 +181,7 @@ static napi_value GenerateKeyAsyncWork(napi_env env, GenerateKeyAsyncContext *co napi_value HuksNapiGenerateKey(napi_env env, napi_callback_info info) { - GenerateKeyAsyncContext *context = CreateGenerateKeyAsyncContext(); - + GenerateKeyAsyncContext context = CreateGenerateKeyAsyncContext(); if (context == nullptr) { HKS_LOG_E("could not create context"); return nullptr; diff --git a/interfaces/kits/napi/src/huks_napi_get_certificate_chain.cpp b/interfaces/kits/napi/src/huks_napi_get_certificate_chain.cpp new file mode 100755 index 00000000..f273f0e6 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_get_certificate_chain.cpp @@ -0,0 +1,222 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_get_certificate_chain.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_GET_CERTIFICATE_CHAIN_MIN_ARGS = 2; +constexpr int HUKS_NAPI_GET_CERTIFICATE_CHAIN_MAX_ARGS = 3; +} // namespace + +struct GetCertificateChainAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *keyAlias = nullptr; + struct HksCertChain *certChain = nullptr; +}; +using GetCertificateChainAsyncContext = GetCertificateChainAsyncContext_t *; + +static GetCertificateChainAsyncContext CreateGetCertificateChainAsyncContext() +{ + GetCertificateChainAsyncContext context = + (GetCertificateChainAsyncContext)HksMalloc(sizeof(GetCertificateChainAsyncContext_t)); + if (context != nullptr) { + (void)memset_s( + context, sizeof(GetCertificateChainAsyncContext_t), 0, sizeof(GetCertificateChainAsyncContext_t)); + } + return context; +} + +static void DeleteGetCertificateChainAsyncContext(napi_env env, GetCertificateChainAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->certChain != nullptr) { + FreeHksCertChain(context->certChain); + } + + HksFree(context); +} + +static napi_value GetCertificateChainParseParams( + napi_env env, napi_callback_info info, GetCertificateChainAsyncContext context) +{ + size_t argc = HUKS_NAPI_GET_CERTIFICATE_CHAIN_MAX_ARGS; + napi_value argv[HUKS_NAPI_GET_CERTIFICATE_CHAIN_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_GET_CERTIFICATE_CHAIN_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value GetCertificateChainWriteResult(napi_env env, GetCertificateChainAsyncContext context) +{ + napi_value result = GenerateHksResult(env, context->result, nullptr, 0); + if (result != nullptr) { + napi_value certChains = GenerateStringArray(env, context->certChain->certs, context->certChain->certsCount); + if (certChains != nullptr) { + napi_set_named_property(env, result, HKS_RESULT_PRPPERTY_CERTCHAINS.c_str(), certChains); + } + } + return result; +} + +static napi_value GetCertificateChainAsyncWork(napi_env env, GetCertificateChainAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "getCertificateChainAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + GetCertificateChainAsyncContext context = static_cast(data); + + context->certChain = (struct HksCertChain *)HksMalloc(sizeof(struct HksCertChain)); + if (context->certChain != nullptr) { + context->certChain->certs = nullptr; + context->certChain->certsCount = 0; + } + + context->result = HksGetCertificateChain(context->keyAlias, context->paramSet, context->certChain); + }, + [](napi_env env, napi_status status, void *data) { + GetCertificateChainAsyncContext context = static_cast(data); + napi_value result = GetCertificateChainWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteGetCertificateChainAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteGetCertificateChainAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiGetCertificateChain(napi_env env, napi_callback_info info) +{ + GetCertificateChainAsyncContext context = CreateGetCertificateChainAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = GetCertificateChainParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteGetCertificateChainAsyncContext(env, context); + return nullptr; + } + + result = GetCertificateChainAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteGetCertificateChainAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_get_key_properties.cpp b/interfaces/kits/napi/src/huks_napi_get_key_properties.cpp index 6c492091..92085e54 100755 --- a/interfaces/kits/napi/src/huks_napi_get_key_properties.cpp +++ b/interfaces/kits/napi/src/huks_napi_get_key_properties.cpp @@ -32,7 +32,7 @@ constexpr int HUKS_NAPI_GET_KEY_PROPERTIES_MAX_ARGS = 3; constexpr int HKS_DEFAULT_OUTPARAMSET_SIZE = 2048; } // namespace -struct GetKeyPropertiesAsyncContext { +struct GetKeyPropertiesAsyncContext_t { napi_async_work asyncWork = nullptr; napi_deferred deferred = nullptr; napi_ref callback = nullptr; @@ -42,18 +42,19 @@ struct GetKeyPropertiesAsyncContext { struct HksParamSet *paramSetIn = nullptr; struct HksParamSet *paramSetOut = nullptr; }; +using GetKeyPropertiesAsyncContext = GetKeyPropertiesAsyncContext_t *; -static GetKeyPropertiesAsyncContext *CreateGetKeyPropertiesAsyncContext() +static GetKeyPropertiesAsyncContext CreateGetKeyPropertiesAsyncContext() { - GetKeyPropertiesAsyncContext *context = - (GetKeyPropertiesAsyncContext *)HksMalloc(sizeof(GetKeyPropertiesAsyncContext)); + GetKeyPropertiesAsyncContext context = + (GetKeyPropertiesAsyncContext)HksMalloc(sizeof(GetKeyPropertiesAsyncContext_t)); if (context != nullptr) { - (void)memset_s(context, sizeof(GetKeyPropertiesAsyncContext), 0, sizeof(GetKeyPropertiesAsyncContext)); + (void)memset_s(context, sizeof(GetKeyPropertiesAsyncContext_t), 0, sizeof(GetKeyPropertiesAsyncContext_t)); } return context; } -static void DeleteGetKeyPropertiesAsyncContext(napi_env env, GetKeyPropertiesAsyncContext *context) +static void DeleteGetKeyPropertiesAsyncContext(napi_env env, GetKeyPropertiesAsyncContext context) { if (context == nullptr) { return; @@ -85,7 +86,7 @@ static void DeleteGetKeyPropertiesAsyncContext(napi_env env, GetKeyPropertiesAsy } static napi_value GetKeyPropertiesParseParams( - napi_env env, napi_callback_info info, GetKeyPropertiesAsyncContext *context) + napi_env env, napi_callback_info info, GetKeyPropertiesAsyncContext context) { size_t argc = HUKS_NAPI_GET_KEY_PROPERTIES_MAX_ARGS; napi_value argv[HUKS_NAPI_GET_KEY_PROPERTIES_MAX_ARGS] = {0}; @@ -127,12 +128,12 @@ static napi_value GetKeyPropertiesParseParams( return GetInt32(env, 0); } -static napi_value GetKeyPropertiesWriteResult(napi_env env, GetKeyPropertiesAsyncContext *context) +static napi_value GetKeyPropertiesWriteResult(napi_env env, GetKeyPropertiesAsyncContext context) { - return GenerateHksResult(env, context->result, nullptr, 0, context->paramSetOut); + return GenerateHksResult(env, context->result, nullptr, 0, *context->paramSetOut); } -static napi_value GetKeyPropertiesAsyncWork(napi_env env, GetKeyPropertiesAsyncContext *context) +static napi_value GetKeyPropertiesAsyncWork(napi_env env, GetKeyPropertiesAsyncContext context) { napi_value promise = nullptr; if (context->callback == nullptr) { @@ -147,17 +148,17 @@ static napi_value GetKeyPropertiesAsyncWork(napi_env env, GetKeyPropertiesAsyncC nullptr, resourceName, [](napi_env env, void *data) { - GetKeyPropertiesAsyncContext *context = static_cast(data); + GetKeyPropertiesAsyncContext context = static_cast(data); context->paramSetOut = (struct HksParamSet *)HksMalloc(HKS_DEFAULT_OUTPARAMSET_SIZE); if (context->paramSetOut) { context->paramSetOut->paramSetSize = HKS_DEFAULT_OUTPARAMSET_SIZE; } - context->result = HksGenerateKey(context->keyAlias, context->paramSetIn, context->paramSetOut); + context->result = HksGetKeyParamSet(context->keyAlias, context->paramSetIn, context->paramSetOut); }, [](napi_env env, napi_status status, void *data) { - GetKeyPropertiesAsyncContext *context = static_cast(data); + GetKeyPropertiesAsyncContext context = static_cast(data); napi_value result = GetKeyPropertiesWriteResult(env, context); if (result == nullptr) { return; @@ -189,8 +190,7 @@ static napi_value GetKeyPropertiesAsyncWork(napi_env env, GetKeyPropertiesAsyncC napi_value HuksNapiGetKeyProperties(napi_env env, napi_callback_info info) { - GetKeyPropertiesAsyncContext *context = CreateGetKeyPropertiesAsyncContext(); - + GetKeyPropertiesAsyncContext context = CreateGetKeyPropertiesAsyncContext(); if (context == nullptr) { HKS_LOG_E("could not create context"); return nullptr; diff --git a/interfaces/kits/napi/src/huks_napi_import_key.cpp b/interfaces/kits/napi/src/huks_napi_import_key.cpp index 7f6eb1c1..ce001bc4 100755 --- a/interfaces/kits/napi/src/huks_napi_import_key.cpp +++ b/interfaces/kits/napi/src/huks_napi_import_key.cpp @@ -30,7 +30,7 @@ constexpr int HUKS_NAPI_IMPORT_KEY_MIN_ARGS = 2; constexpr int HUKS_NAPI_IMPORT_KEY_MAX_ARGS = 3; } // namespace -struct ImportKeyAsyncContext { +struct ImportKeyAsyncContext_t { napi_async_work asyncWork = nullptr; napi_deferred deferred = nullptr; napi_ref callback = nullptr; @@ -40,17 +40,18 @@ struct ImportKeyAsyncContext { struct HksParamSet *paramSet = nullptr; struct HksBlob *key = nullptr; }; +using ImportKeyAsyncContext = ImportKeyAsyncContext_t *; -static ImportKeyAsyncContext *CreateImportKeyAsyncContext() +static ImportKeyAsyncContext CreateImportKeyAsyncContext() { - ImportKeyAsyncContext *context = (ImportKeyAsyncContext *)HksMalloc(sizeof(ImportKeyAsyncContext)); + ImportKeyAsyncContext context = (ImportKeyAsyncContext)HksMalloc(sizeof(ImportKeyAsyncContext_t)); if (context != nullptr) { - (void)memset_s(context, sizeof(ImportKeyAsyncContext), 0, sizeof(ImportKeyAsyncContext)); + (void)memset_s(context, sizeof(ImportKeyAsyncContext_t), 0, sizeof(ImportKeyAsyncContext_t)); } return context; } -static void DeleteImportKeyAsyncContext(napi_env env, ImportKeyAsyncContext *context) +static void DeleteImportKeyAsyncContext(napi_env env, ImportKeyAsyncContext context) { if (context == nullptr) { return; @@ -84,7 +85,7 @@ static void DeleteImportKeyAsyncContext(napi_env env, ImportKeyAsyncContext *con HksFree(context); } -static napi_value ImportKeyParseParams(napi_env env, napi_callback_info info, ImportKeyAsyncContext *context) +static napi_value ImportKeyParseParams(napi_env env, napi_callback_info info, ImportKeyAsyncContext context) { size_t argc = HUKS_NAPI_IMPORT_KEY_MAX_ARGS; napi_value argv[HUKS_NAPI_IMPORT_KEY_MAX_ARGS] = {0}; @@ -125,6 +126,10 @@ static napi_value ImportKeyParseParams(napi_env env, napi_callback_info info, Im return nullptr; } context->key = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->key == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } result = GetUint8Array(env, inData, *context->key); if (result == nullptr) { HKS_LOG_E("could not get indata"); @@ -139,12 +144,12 @@ static napi_value ImportKeyParseParams(napi_env env, napi_callback_info info, Im return GetInt32(env, 0); } -static napi_value ImportKeyWriteResult(napi_env env, ImportKeyAsyncContext *context) +static napi_value ImportKeyWriteResult(napi_env env, ImportKeyAsyncContext context) { return GenerateHksResult(env, context->result, nullptr, 0); } -static napi_value ImportKeyAsyncWork(napi_env env, ImportKeyAsyncContext *context) +static napi_value ImportKeyAsyncWork(napi_env env, ImportKeyAsyncContext context) { napi_value promise = nullptr; if (context->callback == nullptr) { @@ -159,12 +164,12 @@ static napi_value ImportKeyAsyncWork(napi_env env, ImportKeyAsyncContext *contex nullptr, resourceName, [](napi_env env, void *data) { - ImportKeyAsyncContext *context = static_cast(data); + ImportKeyAsyncContext context = static_cast(data); context->result = HksImportKey(context->keyAlias, context->paramSet, context->key); }, [](napi_env env, napi_status status, void *data) { - ImportKeyAsyncContext *context = static_cast(data); + ImportKeyAsyncContext context = static_cast(data); napi_value result = ImportKeyWriteResult(env, context); if (result == nullptr) { return; @@ -196,8 +201,7 @@ static napi_value ImportKeyAsyncWork(napi_env env, ImportKeyAsyncContext *contex napi_value HuksNapiImportKey(napi_env env, napi_callback_info info) { - ImportKeyAsyncContext *context = CreateImportKeyAsyncContext(); - + ImportKeyAsyncContext context = CreateImportKeyAsyncContext(); if (context == nullptr) { HKS_LOG_E("could not create context"); return nullptr; diff --git a/interfaces/kits/napi/src/huks_napi_is_key_exist.cpp b/interfaces/kits/napi/src/huks_napi_is_key_exist.cpp index fa3180bc..67587bcb 100755 --- a/interfaces/kits/napi/src/huks_napi_is_key_exist.cpp +++ b/interfaces/kits/napi/src/huks_napi_is_key_exist.cpp @@ -30,7 +30,7 @@ constexpr int HUKS_NAPI_IS_KEY_EXIST_MIN_ARGS = 2; constexpr int HUKS_NAPI_IS_KEY_EXIST_MAX_ARGS = 3; } // namespace -struct IsKeyExistAsyncContext { +struct IsKeyExistAsyncContext_t { napi_async_work asyncWork = nullptr; napi_deferred deferred = nullptr; napi_ref callback = nullptr; @@ -39,17 +39,18 @@ struct IsKeyExistAsyncContext { struct HksBlob *keyAlias = nullptr; struct HksParamSet *paramSet = nullptr; }; +using IsKeyExistAsyncContext = IsKeyExistAsyncContext_t *; -static IsKeyExistAsyncContext *CreateIsKeyExistAsyncContext() +static IsKeyExistAsyncContext CreateIsKeyExistAsyncContext() { - IsKeyExistAsyncContext *context = (IsKeyExistAsyncContext *)HksMalloc(sizeof(IsKeyExistAsyncContext)); + IsKeyExistAsyncContext context = (IsKeyExistAsyncContext)HksMalloc(sizeof(IsKeyExistAsyncContext_t)); if (context != nullptr) { - (void)memset_s(context, sizeof(IsKeyExistAsyncContext), 0, sizeof(IsKeyExistAsyncContext)); + (void)memset_s(context, sizeof(IsKeyExistAsyncContext_t), 0, sizeof(IsKeyExistAsyncContext_t)); } return context; } -static void DeleteIsKeyExistAsyncContext(napi_env env, IsKeyExistAsyncContext *context) +static void DeleteIsKeyExistAsyncContext(napi_env env, IsKeyExistAsyncContext context) { if (context == nullptr) { return; @@ -76,7 +77,7 @@ static void DeleteIsKeyExistAsyncContext(napi_env env, IsKeyExistAsyncContext *c HksFree(context); } -static napi_value IsKeyExistParseParams(napi_env env, napi_callback_info info, IsKeyExistAsyncContext *context) +static napi_value IsKeyExistParseParams(napi_env env, napi_callback_info info, IsKeyExistAsyncContext context) { size_t argc = HUKS_NAPI_IS_KEY_EXIST_MAX_ARGS; napi_value argv[HUKS_NAPI_IS_KEY_EXIST_MAX_ARGS] = {0}; @@ -118,7 +119,7 @@ static napi_value IsKeyExistParseParams(napi_env env, napi_callback_info info, I return GetInt32(env, 0); } -static napi_value IsKeyExistWriteResult(napi_env env, IsKeyExistAsyncContext *context) +static napi_value IsKeyExistWriteResult(napi_env env, IsKeyExistAsyncContext context) { napi_value isKeyExist = nullptr; if (context->result == HKS_SUCCESS) { @@ -129,7 +130,7 @@ static napi_value IsKeyExistWriteResult(napi_env env, IsKeyExistAsyncContext *co return isKeyExist; } -static napi_value IsKeyExistAsyncWork(napi_env env, IsKeyExistAsyncContext *context) +static napi_value IsKeyExistAsyncWork(napi_env env, IsKeyExistAsyncContext context) { napi_value promise = nullptr; if (context->callback == nullptr) { @@ -144,12 +145,12 @@ static napi_value IsKeyExistAsyncWork(napi_env env, IsKeyExistAsyncContext *cont nullptr, resourceName, [](napi_env env, void *data) { - IsKeyExistAsyncContext *context = static_cast(data); + IsKeyExistAsyncContext context = static_cast(data); context->result = HksKeyExist(context->keyAlias, context->paramSet); }, [](napi_env env, napi_status status, void *data) { - IsKeyExistAsyncContext *context = static_cast(data); + IsKeyExistAsyncContext context = static_cast(data); napi_value result = IsKeyExistWriteResult(env, context); if (result == nullptr) { return; @@ -181,8 +182,7 @@ static napi_value IsKeyExistAsyncWork(napi_env env, IsKeyExistAsyncContext *cont napi_value HuksNapiIsKeyExist(napi_env env, napi_callback_info info) { - IsKeyExistAsyncContext *context = CreateIsKeyExistAsyncContext(); - + IsKeyExistAsyncContext context = CreateIsKeyExistAsyncContext(); if (context == nullptr) { HKS_LOG_E("could not create context"); return nullptr; diff --git a/interfaces/kits/napi/src/huks_napi_mac.cpp b/interfaces/kits/napi/src/huks_napi_mac.cpp new file mode 100755 index 00000000..dc68a701 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_mac.cpp @@ -0,0 +1,246 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_mac.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_AGREE_KEY_MIN_ARGS = 2; +constexpr int HUKS_NAPI_AGREE_KEY_MAX_ARGS = 3; + +constexpr int HKS_MAX_MAC_SIZE = 512; +} // namespace + +struct MacAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *srcData = nullptr; + struct HksBlob *mac = nullptr; +}; +using MacAsyncContext = MacAsyncContext_t *; + +static MacAsyncContext CreateMacAsyncContext() +{ + MacAsyncContext context = (MacAsyncContext)HksMalloc(sizeof(MacAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(MacAsyncContext_t), 0, sizeof(MacAsyncContext_t)); + } + return context; +} + +static void DeleteMacAsyncContext(napi_env env, MacAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->srcData != nullptr) { + if (context->srcData->data != nullptr && context->srcData->size != 0) { + (void)memset_s(context->srcData->data, context->srcData->size, 0, context->srcData->size); + } + FreeHksBlob(context->srcData); + } + + if (context->mac != nullptr) { + if (context->mac->data != nullptr && context->mac->size != 0) { + (void)memset_s(context->mac->data, context->mac->size, 0, context->mac->size); + } + FreeHksBlob(context->mac); + } + + HksFree(context); +} + +static napi_value MacParseParams(napi_env env, napi_callback_info info, MacAsyncContext context) +{ + size_t argc = HUKS_NAPI_AGREE_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_AGREE_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_AGREE_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->srcData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->srcData == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->srcData); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value MacWriteResult(napi_env env, MacAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->mac != nullptr) ? context->mac->data : nullptr), + (context->result == HKS_SUCCESS && context->mac != nullptr) ? context->mac->size : 0); +} + +static napi_value MacAsyncWork(napi_env env, MacAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "macAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + MacAsyncContext context = static_cast(data); + + context->mac = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->mac != nullptr) { + context->mac->data = (uint8_t *)HksMalloc(HKS_MAX_MAC_SIZE); + context->mac->size = HKS_MAX_MAC_SIZE; + } + + context->result = HksMac(context->keyAlias, context->paramSet, context->srcData, context->mac); + }, + [](napi_env env, napi_status status, void *data) { + MacAsyncContext context = static_cast(data); + napi_value result = MacWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteMacAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteMacAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiMac(napi_env env, napi_callback_info info) +{ + MacAsyncContext context = CreateMacAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = MacParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteMacAsyncContext(env, context); + return nullptr; + } + + result = MacAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteMacAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_sign.cpp b/interfaces/kits/napi/src/huks_napi_sign.cpp new file mode 100755 index 00000000..127874bf --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_sign.cpp @@ -0,0 +1,245 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_sign.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_SIGN_MIN_ARGS = 2; +constexpr int HUKS_NAPI_SIGN_MAX_ARGS = 3; + +constexpr int HKS_MAX_SIGNATURE_SIZE = 512; +} // namespace + +struct SignAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *srcData = nullptr; + struct HksBlob *signature = nullptr; +}; +using SignAsyncContext = SignAsyncContext_t *; + +static SignAsyncContext CreateSignAsyncContext() +{ + SignAsyncContext context = (SignAsyncContext)HksMalloc(sizeof(SignAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(SignAsyncContext_t), 0, sizeof(SignAsyncContext_t)); + } + return context; +} + +static void DeleteSignAsyncContext(napi_env env, SignAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->srcData != nullptr) { + if (context->srcData->data != nullptr && context->srcData->size != 0) { + (void)memset_s(context->srcData->data, context->srcData->size, 0, context->srcData->size); + } + FreeHksBlob(context->srcData); + } + + if (context->signature != nullptr) { + if (context->signature->data != nullptr && context->signature->size != 0) { + (void)memset_s(context->signature->data, context->signature->size, 0, context->signature->size); + } + FreeHksBlob(context->signature); + } + + HksFree(context); +} + +static napi_value SignParseParams(napi_env env, napi_callback_info info, SignAsyncContext context) +{ + size_t argc = HUKS_NAPI_SIGN_MAX_ARGS; + napi_value argv[HUKS_NAPI_SIGN_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_SIGN_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + napi_value inData = nullptr; + status = napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->srcData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->srcData == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->srcData); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value SignWriteResult(napi_env env, SignAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->signature != nullptr) ? context->signature->data : nullptr), + (context->result == HKS_SUCCESS && context->signature != nullptr) ? context->signature->size : 0); +} + +static napi_value SignAsyncWork(napi_env env, SignAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "signAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + SignAsyncContext context = static_cast(data); + + context->signature = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->signature != NULL) { + context->signature->data = (uint8_t *)HksMalloc(HKS_MAX_SIGNATURE_SIZE); + context->signature->size = HKS_MAX_SIGNATURE_SIZE; + } + + context->result = HksSign(context->keyAlias, context->paramSet, context->srcData, context->signature); + }, + [](napi_env env, napi_status status, void *data) { + SignAsyncContext context = static_cast(data); + napi_value result = SignWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteSignAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteSignAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiSign(napi_env env, napi_callback_info info) +{ + SignAsyncContext context = CreateSignAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = SignParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteSignAsyncContext(env, context); + return nullptr; + } + + result = SignAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteSignAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_unwrap_key.cpp b/interfaces/kits/napi/src/huks_napi_unwrap_key.cpp new file mode 100755 index 00000000..b5ea6e78 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_unwrap_key.cpp @@ -0,0 +1,251 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_unwrap_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_WRAP_KEY_MIN_ARGS = 3; +constexpr int HUKS_NAPI_WRAP_KEY_MAX_ARGS = 4; +} // namespace + +struct UnwrapKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *targetKeyAlias = nullptr; + struct HksBlob *wrappedData = nullptr; + struct HksParamSet *paramSet = nullptr; +}; +using UnwrapKeyAsyncContext = UnwrapKeyAsyncContext_t *; + +static UnwrapKeyAsyncContext CreateUnwrapKeyAsyncContext() +{ + UnwrapKeyAsyncContext context = (UnwrapKeyAsyncContext)HksMalloc(sizeof(UnwrapKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(UnwrapKeyAsyncContext_t), 0, sizeof(UnwrapKeyAsyncContext_t)); + } + return context; +} + +static void DeleteUnwrapKeyAsyncContext(napi_env env, UnwrapKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->targetKeyAlias != nullptr) { + FreeHksBlob(context->targetKeyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->wrappedData != nullptr) { + if (context->wrappedData->data != nullptr && context->wrappedData->size != 0) { + (void)memset_s(context->wrappedData->data, context->wrappedData->size, 0, context->wrappedData->size); + } + FreeHksBlob(context->wrappedData); + } + + HksFree(context); +} + +static napi_value UnwrapKeyParseOptions(napi_env env, napi_value options, UnwrapKeyAsyncContext context) +{ + napi_value result = nullptr; + + napi_value properties = nullptr; + napi_status status = napi_get_named_property(env, options, HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + napi_value inData = nullptr; + status = napi_get_named_property(env, options, HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->wrappedData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->wrappedData == nullptr) { + HKS_LOG_E("could not alloc memory"); + return nullptr; + } + result = GetUint8Array(env, inData, *context->wrappedData); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + return GetInt32(env, 0); +} + +static napi_value UnwrapKeyParseParams(napi_env env, napi_callback_info info, UnwrapKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_WRAP_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_WRAP_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_WRAP_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + result = ParseKeyAlias(env, argv[index], context->targetKeyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get target alias"); + return nullptr; + } + + index++; + result = UnwrapKeyParseOptions(env, argv[index], context); + if (result == nullptr) { + HKS_LOG_E("could not parse options"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value UnwrapKeyWriteResult(napi_env env, UnwrapKeyAsyncContext context) +{ + return GenerateHksResult(env, context->result, nullptr, 0); +} + +static napi_value UnwrapKeyAsyncWork(napi_env env, UnwrapKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "unwrapKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + UnwrapKeyAsyncContext context = static_cast(data); + + context->result = + HksUnwrapKey(context->keyAlias, context->targetKeyAlias, context->wrappedData, context->paramSet); + }, + [](napi_env env, napi_status status, void *data) { + UnwrapKeyAsyncContext context = static_cast(data); + napi_value result = UnwrapKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteUnwrapKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteUnwrapKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiUnwrapKey(napi_env env, napi_callback_info info) +{ + UnwrapKeyAsyncContext context = CreateUnwrapKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = UnwrapKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteUnwrapKeyAsyncContext(env, context); + return nullptr; + } + + result = UnwrapKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteUnwrapKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_verify.cpp b/interfaces/kits/napi/src/huks_napi_verify.cpp new file mode 100755 index 00000000..aeabf768 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_verify.cpp @@ -0,0 +1,257 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_verify.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_VERIFY_MIN_ARGS = 3; +constexpr int HUKS_NAPI_VERIFY_MAX_ARGS = 4; +} // namespace + +struct VerifyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *srcData = nullptr; + struct HksBlob *signature = nullptr; +}; +using VerifyAsyncContext = VerifyAsyncContext_t *; + +static VerifyAsyncContext CreateVerifyAsyncContext() +{ + VerifyAsyncContext context = (VerifyAsyncContext)HksMalloc(sizeof(VerifyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(VerifyAsyncContext_t), 0, sizeof(VerifyAsyncContext_t)); + } + return context; +} + +static void DeleteVerifyAsyncContext(napi_env env, VerifyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->srcData != nullptr) { + if (context->srcData->data != nullptr && context->srcData->size != 0) { + (void)memset_s(context->srcData->data, context->srcData->size, 0, context->srcData->size); + } + FreeHksBlob(context->srcData); + } + + if (context->signature != nullptr) { + if (context->signature->data != nullptr && context->signature->size != 0) { + (void)memset_s(context->signature->data, context->signature->size, 0, context->signature->size); + } + FreeHksBlob(context->signature); + } + + HksFree(context); +} + +static napi_value VerifyParseOptions(napi_env env, napi_value options, VerifyAsyncContext context) +{ + napi_value result = nullptr; + + napi_value properties = nullptr; + napi_status status = napi_get_named_property(env, options, HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + napi_value inData = nullptr; + status = napi_get_named_property(env, options, HKS_OPTIONS_PROPERTY_INDATA.c_str(), &inData); + if (status != napi_ok || inData == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_INDATA.c_str()); + return nullptr; + } + context->srcData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->srcData == nullptr) { + return nullptr; + } + result = GetUint8Array(env, inData, *context->srcData); + if (result == nullptr) { + HKS_LOG_E("could not get indata"); + return nullptr; + } + + return GetInt32(env, 0); +} + +static napi_value VerifyParseParams(napi_env env, napi_callback_info info, VerifyAsyncContext context) +{ + size_t argc = HUKS_NAPI_VERIFY_MAX_ARGS; + napi_value argv[HUKS_NAPI_VERIFY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_VERIFY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + result = VerifyParseOptions(env, argv[index], context); + if (result == nullptr) { + HKS_LOG_E("could not parse options"); + return nullptr; + } + + index++; + context->signature = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->signature == nullptr) { + return nullptr; + } + result = GetUint8Array(env, argv[index], *context->signature); + if (result == nullptr) { + HKS_LOG_E("could not get signature"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value VerifyWriteResult(napi_env env, VerifyAsyncContext context) +{ + return GenerateHksResult(env, context->result, nullptr, 0); +} + +static napi_value VerifyAsyncWork(napi_env env, VerifyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "verifyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + VerifyAsyncContext context = static_cast(data); + + context->result = HksVerify(context->keyAlias, context->paramSet, context->srcData, context->signature); + }, + [](napi_env env, napi_status status, void *data) { + VerifyAsyncContext context = static_cast(data); + napi_value result = VerifyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteVerifyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteVerifyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiVerify(napi_env env, napi_callback_info info) +{ + VerifyAsyncContext context = CreateVerifyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = VerifyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteVerifyAsyncContext(env, context); + return nullptr; + } + + result = VerifyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteVerifyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/interfaces/kits/napi/src/huks_napi_wrap_key.cpp b/interfaces/kits/napi/src/huks_napi_wrap_key.cpp new file mode 100755 index 00000000..689c9ab5 --- /dev/null +++ b/interfaces/kits/napi/src/huks_napi_wrap_key.cpp @@ -0,0 +1,233 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "huks_napi_wrap_key.h" + +#include "securec.h" + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" +#include "hks_type.h" +#include "huks_napi_common.h" + +namespace HuksNapi { +namespace { +constexpr int HUKS_NAPI_UNWRAP_KEY_MIN_ARGS = 3; +constexpr int HUKS_NAPI_UNWRAP_KEY_MAX_ARGS = 4; + +constexpr int HKS_MAX_WRAPPED_DATA_SIZE = 2048; +} // namespace + +struct WrapKeyAsyncContext_t { + napi_async_work asyncWork = nullptr; + napi_deferred deferred = nullptr; + napi_ref callback = nullptr; + + int32_t result = 0; + struct HksBlob *keyAlias = nullptr; + struct HksBlob *targetKeyAlias = nullptr; + struct HksParamSet *paramSet = nullptr; + struct HksBlob *wrappedData = nullptr; +}; +using WrapKeyAsyncContext = WrapKeyAsyncContext_t *; + +static WrapKeyAsyncContext CreateWrapKeyAsyncContext() +{ + WrapKeyAsyncContext context = (WrapKeyAsyncContext)HksMalloc(sizeof(WrapKeyAsyncContext_t)); + if (context != nullptr) { + (void)memset_s(context, sizeof(WrapKeyAsyncContext_t), 0, sizeof(WrapKeyAsyncContext_t)); + } + return context; +} + +static void DeleteWrapKeyAsyncContext(napi_env env, WrapKeyAsyncContext context) +{ + if (context == nullptr) { + return; + } + + if (context->asyncWork != nullptr) { + napi_delete_async_work(env, context->asyncWork); + context->asyncWork = nullptr; + } + + if (context->callback != nullptr) { + napi_delete_reference(env, context->callback); + context->callback = nullptr; + } + + if (context->keyAlias != nullptr) { + FreeHksBlob(context->keyAlias); + } + + if (context->targetKeyAlias != nullptr) { + FreeHksBlob(context->targetKeyAlias); + } + + if (context->paramSet != nullptr) { + HksFreeParamSet(&context->paramSet); + } + + if (context->wrappedData != nullptr) { + if (context->wrappedData->data != nullptr && context->wrappedData->size != 0) { + (void)memset_s(context->wrappedData->data, context->wrappedData->size, 0, context->wrappedData->size); + } + FreeHksBlob(context->wrappedData); + } + + HksFree(context); +} + +static napi_value WrapKeyParseParams(napi_env env, napi_callback_info info, WrapKeyAsyncContext context) +{ + size_t argc = HUKS_NAPI_UNWRAP_KEY_MAX_ARGS; + napi_value argv[HUKS_NAPI_UNWRAP_KEY_MAX_ARGS] = {0}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + + if (argc < HUKS_NAPI_UNWRAP_KEY_MIN_ARGS) { + napi_throw_error(env, NULL, "invalid arguments"); + HKS_LOG_E("no enough params"); + return nullptr; + } + + size_t index = 0; + napi_value result = ParseKeyAlias(env, argv[index], context->keyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get alias"); + return nullptr; + } + + index++; + result = ParseKeyAlias(env, argv[index], context->targetKeyAlias); + if (result == nullptr) { + HKS_LOG_E("could not get target alias"); + return nullptr; + } + + index++; + napi_value properties = nullptr; + napi_status status = + napi_get_named_property(env, argv[index], HKS_OPTIONS_PROPERTY_PROPERTIES.c_str(), &properties); + if (status != napi_ok || properties == nullptr) { + GET_AND_THROW_LAST_ERROR((env)); + HKS_LOG_E("could not get property %s", HKS_OPTIONS_PROPERTY_PROPERTIES.c_str()); + return nullptr; + } + result = ParseHksParamSet(env, properties, context->paramSet); + if (result == nullptr) { + HKS_LOG_E("could not get paramset"); + return nullptr; + } + + index++; + if (index < argc) { + context->callback = GetCallback(env, argv[index]); + } + + return GetInt32(env, 0); +} + +static napi_value WrapKeyWriteResult(napi_env env, WrapKeyAsyncContext context) +{ + return GenerateHksResult(env, + context->result, + ((context->result == HKS_SUCCESS && context->wrappedData != nullptr) ? context->wrappedData->data : nullptr), + (context->result == HKS_SUCCESS && context->wrappedData != nullptr) ? context->wrappedData->size : 0); +} + +static napi_value WrapKeyAsyncWork(napi_env env, WrapKeyAsyncContext context) +{ + napi_value promise = nullptr; + if (context->callback == nullptr) { + NAPI_CALL(env, napi_create_promise(env, &context->deferred, &promise)); + } + + napi_value resourceName; + napi_create_string_latin1(env, "wrapKeyAsyncWork", NAPI_AUTO_LENGTH, &resourceName); + + napi_create_async_work( + env, + nullptr, + resourceName, + [](napi_env env, void *data) { + WrapKeyAsyncContext context = static_cast(data); + + context->wrappedData = (HksBlob *)HksMalloc(sizeof(HksBlob)); + if (context->wrappedData != nullptr) { + context->wrappedData->data = (uint8_t *)HksMalloc(HKS_MAX_WRAPPED_DATA_SIZE); + context->wrappedData->size = HKS_MAX_WRAPPED_DATA_SIZE; + } + + context->result = + HksWrapKey(context->keyAlias, context->targetKeyAlias, context->paramSet, context->wrappedData); + }, + [](napi_env env, napi_status status, void *data) { + WrapKeyAsyncContext context = static_cast(data); + napi_value result = WrapKeyWriteResult(env, context); + if (result == nullptr) { + return; + } + if (context->callback != nullptr) { + CallAsyncCallback(env, context->callback, context->result, result); + } else { + napi_resolve_deferred(env, context->deferred, result); + } + DeleteWrapKeyAsyncContext(env, context); + }, + (void *)context, + &context->asyncWork); + + napi_status status = napi_queue_async_work(env, context->asyncWork); + if (status != napi_ok) { + GET_AND_THROW_LAST_ERROR((env)); + DeleteWrapKeyAsyncContext(env, context); + HKS_LOG_E("could not queue async work"); + return nullptr; + } + + if (context->callback == nullptr) { + return promise; + } else { + return GetNull(env); + } + return nullptr; +} + +napi_value HuksNapiWrapKey(napi_env env, napi_callback_info info) +{ + WrapKeyAsyncContext context = CreateWrapKeyAsyncContext(); + if (context == nullptr) { + HKS_LOG_E("could not create context"); + return nullptr; + } + + napi_value result = WrapKeyParseParams(env, info, context); + if (result == nullptr) { + HKS_LOG_E("could not parse params"); + DeleteWrapKeyAsyncContext(env, context); + return nullptr; + } + + result = WrapKeyAsyncWork(env, context); + if (result == nullptr) { + HKS_LOG_E("could not start async work"); + DeleteWrapKeyAsyncContext(env, context); + return nullptr; + } + return result; +} +} // namespace HuksNapi diff --git a/services/huks_standard/huks_engine/main/core/src/hks_core_service.c b/services/huks_standard/huks_engine/main/core/src/hks_core_service.c index 38f061ae..54ca0abe 100755 --- a/services/huks_standard/huks_engine/main/core/src/hks_core_service.c +++ b/services/huks_standard/huks_engine/main/core/src/hks_core_service.c @@ -305,6 +305,8 @@ static int32_t SignVerifyAuth(const struct HksKeyNode *keyNode, const struct Hks return HksAuth(HKS_AUTH_ID_SIGN_VERIFY_RSA, keyNode, paramSet); } else if (algParam->uint32Param == HKS_ALG_ECC) { return HksAuth(HKS_AUTH_ID_SIGN_VERIFY_ECC, keyNode, paramSet); + } else if (algParam->uint32Param == HKS_ALG_DSA) { + return HKS_SUCCESS; } else if (algParam->uint32Param == HKS_ALG_ED25519) { return HKS_SUCCESS; } else { @@ -313,7 +315,7 @@ static int32_t SignVerifyAuth(const struct HksKeyNode *keyNode, const struct Hks } static int32_t GetSignVerifyMessage(const struct HksParamSet *paramSet, const struct HksBlob *srcData, - struct HksBlob *message, bool *isEd25519) + struct HksBlob *message, bool *needFree) { struct HksParam *algParam = NULL; int32_t ret = HksGetParam(paramSet, HKS_TAG_ALGORITHM, &algParam); @@ -322,7 +324,8 @@ static int32_t GetSignVerifyMessage(const struct HksParamSet *paramSet, const st return HKS_ERROR_CHECK_GET_ALG_FAIL; } - if (algParam->uint32Param != HKS_ALG_ED25519) { + if (algParam->uint32Param != HKS_ALG_ED25519 && algParam->uint32Param != HKS_ALG_RSA && + algParam->uint32Param != HKS_ALG_DSA && algParam->uint32Param != HKS_ALG_ECC) { struct HksParam *digestParam = NULL; ret = HksGetParam(paramSet, HKS_TAG_DIGEST, &digestParam); if (ret != HKS_SUCCESS) { @@ -344,11 +347,11 @@ static int32_t GetSignVerifyMessage(const struct HksParamSet *paramSet, const st return ret; } - *isEd25519 = false; + *needFree = true; } else { message->size = srcData->size; message->data = srcData->data; - *isEd25519 = true; + *needFree = false; } return HKS_SUCCESS; @@ -369,7 +372,7 @@ static int32_t SignVerify(uint32_t cmdId, const struct HksBlob *key, const struc return HKS_ERROR_BAD_STATE; } - bool isEd25519 = true; + bool needFree = true; struct HksBlob message = { 0, NULL }; do { ret = SignVerifyAuth(keyNode, paramSet); @@ -377,7 +380,7 @@ static int32_t SignVerify(uint32_t cmdId, const struct HksBlob *key, const struc break; } - ret = GetSignVerifyMessage(keyNode->paramSet, srcData, &message, &isEd25519); + ret = GetSignVerifyMessage(keyNode->paramSet, srcData, &message, &needFree); if (ret != HKS_SUCCESS) { HKS_LOG_E("SignVerify calc hash failed!"); break; @@ -402,7 +405,7 @@ static int32_t SignVerify(uint32_t cmdId, const struct HksBlob *key, const struc }while (0); HksFreeKeyNode(&keyNode); - if (!isEd25519) { + if (needFree) { HKS_FREE_PTR(message.data); } return ret; diff --git a/services/huks_standard/huks_service/main/core/include/hks_storage_file_lock.h b/services/huks_standard/huks_service/main/core/include/hks_storage_file_lock.h index 5065fe6d..d077116d 100755 --- a/services/huks_standard/huks_service/main/core/include/hks_storage_file_lock.h +++ b/services/huks_standard/huks_service/main/core/include/hks_storage_file_lock.h @@ -22,7 +22,6 @@ extern "C" { #endif - typedef struct HksStorageFileLock HksStorageFileLock; HksStorageFileLock *HksStorageFileLockCreate(char *path); diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_service.c b/services/huks_standard/huks_service/main/core/src/hks_client_service.c index c361f3f6..76e74804 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_client_service.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_service.c @@ -421,11 +421,13 @@ static int32_t GetHksInnerKeyFormat(const struct HksParamSet *paramSet, const st case HKS_ALG_X25519: return TranslateToInnerCurve25519Format(algParam->uint32Param, key, outKey); #endif -#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) +#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) case HKS_ALG_RSA: case HKS_ALG_ECC: case HKS_ALG_ECDH: case HKS_ALG_DSA: + case HKS_ALG_DH: return TranslateFromX509PublicKey(key, outKey); #endif default: diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c b/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c index 53bbac15..55f3b02e 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c @@ -32,7 +32,8 @@ #include "hks_log.h" #include "hks_mem.h" -#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) +#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) static int32_t EvpKeyToX509Format(EVP_PKEY *pkey, struct HksBlob *x509Key) { int32_t length = i2d_PUBKEY(pkey, NULL); @@ -113,10 +114,10 @@ static int32_t GetEccNid(uint32_t keySize, int32_t *nid) { int32_t nids[][2] = { /* 2 is size */ - {224, NID_secp224r1}, - {256, NID_X9_62_prime256v1}, - {384, NID_secp384r1}, - {521, NID_secp521r1}, + { 224, NID_secp224r1 }, + { 256, NID_X9_62_prime256v1 }, + { 384, NID_secp384r1 }, + { 521, NID_secp521r1 }, }; uint32_t nidCount = sizeof(nids) / sizeof(nids[0]); @@ -289,6 +290,77 @@ static int32_t DsaPublicKeyToX509(const struct HksBlob *publicKey, struct HksBlo return DsaToX509PublicKey(&y, &p, &q, &g, x509Key); } +#endif + +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY) +static int32_t GetDhNid(uint32_t keySize, int32_t *nid) +{ + switch (keySize) { + case HKS_DH_KEY_SIZE_2048: + *nid = NID_ffdhe2048; + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_3072: + *nid = NID_ffdhe3072; + return HKS_SUCCESS; + case HKS_DH_KEY_SIZE_4096: + *nid = NID_ffdhe4096; + return HKS_SUCCESS; + default: + return HKS_ERROR_INVALID_ARGUMENT; + } +} + +static int32_t DhToX509PublicKey( + uint32_t keySize, const struct HksBlob *pubKey, const struct HksBlob *privKey, struct HksBlob *x509Key) +{ + int32_t nid; + int32_t ret = GetDhNid(keySize, &nid); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("GetNidFromKeySize fail"); + return ret; + } + + BIGNUM *pub = NULL; + DH *dh = NULL; + EVP_PKEY *pkey = NULL; + do { + dh = DH_new_by_nid(nid); + if (dh == NULL) { + HKS_LOG_E("DH_new_by_nid error:%s", ERR_reason_error_string(ERR_get_error())); + break; + } + + pub = BN_bin2bn(pubKey->data, pubKey->size, NULL); + if (pub == NULL) { + HKS_LOG_E("BN_bin2bn error:%s", ERR_reason_error_string(ERR_get_error())); + break; + } + + if (DH_set0_key(dh, pub, NULL) != 1) { + HKS_LOG_E("DH_set0_key error:%s", ERR_reason_error_string(ERR_get_error())); + break; + } + pub = NULL; + + pkey = EVP_PKEY_new(); + if (pkey == NULL) { + HKS_LOG_E("pkey is null"); + break; + } + + if (EVP_PKEY_set1_DH(pkey, dh) == 0) { + HKS_LOG_E("EVP_PKEY_set1_DH error %s", ERR_reason_error_string(ERR_get_error())); + break; + } + + ret = EvpKeyToX509Format(pkey, x509Key); + } while (0); + + SELF_FREE_PTR(dh, DH_free); + SELF_FREE_PTR(pub, BN_free); + SELF_FREE_PTR(pkey, EVP_PKEY_free); + return ret; +} #endif #endif @@ -336,14 +408,14 @@ int32_t TranslateToX509PublicKey(const struct HksBlob *publicKey, struct HksBlob return HKS_ERROR_INVALID_ARGUMENT; } - struct HksBlob material1 = {publicKeyInfo->nOrXSize, publicKey->data + offset}; + struct HksBlob material1 = { publicKeyInfo->nOrXSize, publicKey->data + offset }; offset += publicKeyInfo->nOrXSize; if ((publicKey->size - offset) < publicKeyInfo->eOrYSize) { HKS_LOG_E("translate to x509 public key invalid eOrYSize size"); return HKS_ERROR_INVALID_ARGUMENT; } - struct HksBlob material2 = {publicKeyInfo->eOrYSize, publicKey->data + offset}; + struct HksBlob material2 = { publicKeyInfo->eOrYSize, publicKey->data + offset }; switch (publicKeyInfo->keyAlg) { #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GET_PUBLIC_KEY) case HKS_ALG_RSA: @@ -354,14 +426,17 @@ int32_t TranslateToX509PublicKey(const struct HksBlob *publicKey, struct HksBlob return EccToX509PublicKey(publicKeyInfo->keySize, &material1, &material2, x509Key); #endif #if defined(HKS_SUPPORT_DSA_C) && defined(HKS_SUPPORT_DSA_GET_PUBLIC_KEY) - case HKS_ALG_DSA: { + case HKS_ALG_DSA: return DsaPublicKeyToX509(publicKey, x509Key); - } #endif #if defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_ED25519_C) case HKS_ALG_X25519: case HKS_ALG_ED25519: return Curve25519ToX509PublicKey(&material1, x509Key); +#endif +#if defined(HKS_SUPPORT_DH_C) && defined(HKS_SUPPORT_DH_GET_PUBLIC_KEY) + case HKS_ALG_DH: + return DhToX509PublicKey(publicKeyInfo->keySize, &material1, NULL, x509Key); #endif default: HKS_LOG_E("Unsupport alg type! type = 0x%X", publicKeyInfo->keyAlg); @@ -369,11 +444,12 @@ int32_t TranslateToX509PublicKey(const struct HksBlob *publicKey, struct HksBlob } } -#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) +#if defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_DSA_C) || \ + defined(HKS_SUPPORT_DH_C) #ifdef HKS_SUPPORT_RSA_C static int32_t X509PublicKeyToRsa(EVP_PKEY *pkey, struct HksBlob *rsaPublicKey) { - RSA *rsa = EVP_PKEY_get1_RSA(pkey); + RSA *rsa = EVP_PKEY_get0_RSA(pkey); if (rsa == NULL) { HKS_LOG_E("EVP_PKEY_get1_RSA error %s", ERR_reason_error_string(ERR_get_error())); return HKS_ERROR_NULL_POINTER; @@ -399,6 +475,7 @@ static int32_t X509PublicKeyToRsa(EVP_PKEY *pkey, struct HksBlob *rsaPublicKey) pubKeyInfo->keySize = RSA_size(rsa) * HKS_BITS_PER_BYTE; pubKeyInfo->nOrXSize = nSize; pubKeyInfo->eOrYSize = eSize; + pubKeyInfo->placeHolder = 0; if (BN_bn2bin(RSA_get0_n(rsa), keyBuffer + sizeof(struct HksPubKeyInfo)) == 0 || BN_bn2bin(RSA_get0_e(rsa), keyBuffer + sizeof(struct HksPubKeyInfo) + nSize) == 0) { HKS_LOG_E("BN_bn2bin error %s", ERR_reason_error_string(ERR_get_error())); @@ -451,6 +528,7 @@ static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey) pubKeyInfo->keySize = EC_GROUP_order_bits(EC_KEY_get0_group(ecKey)); pubKeyInfo->nOrXSize = xSize; pubKeyInfo->eOrYSize = ySize; + pubKeyInfo->placeHolder = 0; if (BN_bn2bin(x, keyBuffer + sizeof(struct HksPubKeyInfo)) == 0 || BN_bn2bin(y, keyBuffer + sizeof(struct HksPubKeyInfo) + xSize) == 0) { HKS_LOG_E("BN_bn2bin error %s", ERR_reason_error_string(ERR_get_error())); @@ -470,7 +548,7 @@ static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey) static int32_t X509PublicKeyToEcc(EVP_PKEY *pkey, struct HksBlob *eccPublicKey) { - EC_KEY *ecKey = EVP_PKEY_get1_EC_KEY(pkey); + EC_KEY *ecKey = EVP_PKEY_get0_EC_KEY(pkey); if (ecKey == NULL) { HKS_LOG_E("EVP_PKEY_get1_EC_KEY error %s", ERR_reason_error_string(ERR_get_error())); return HKS_ERROR_NULL_POINTER; @@ -483,7 +561,7 @@ static int32_t X509PublicKeyToEcc(EVP_PKEY *pkey, struct HksBlob *eccPublicKey) #ifdef HKS_SUPPORT_DSA_C static int32_t X509PublicKeyToDsa(EVP_PKEY *pkey, struct HksBlob *dsaPublicKey) { - DSA *dsa = EVP_PKEY_get1_DSA(pkey); + DSA *dsa = EVP_PKEY_get0_DSA(pkey); if (dsa == NULL) { HKS_LOG_E("EVP_PKEY_get1_DSA error %s", ERR_reason_error_string(ERR_get_error())); return HKS_ERROR_NULL_POINTER; @@ -502,7 +580,7 @@ static int32_t X509PublicKeyToDsa(EVP_PKEY *pkey, struct HksBlob *dsaPublicKey) uint8_t *keyBuffer = HksMalloc(totalSize); struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)keyBuffer; keyMaterial->keyAlg = HKS_ALG_DSA; - keyMaterial->keySize = (ySize + HKS_BITS_PER_BYTE - 1) / HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE; + keyMaterial->keySize = (ySize + HKS_BITS_PER_BYTE - 1) / HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE * HKS_BITS_PER_BYTE; keyMaterial->xSize = 0; keyMaterial->ySize = ySize; keyMaterial->pSize = pSize; @@ -515,13 +593,44 @@ static int32_t X509PublicKeyToDsa(EVP_PKEY *pkey, struct HksBlob *dsaPublicKey) (BN_bn2bin(g, keyBuffer + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize + qSize) == 0)) { HKS_LOG_E("BN_bn2bin error %s", ERR_reason_error_string(ERR_get_error())); HKS_FREE_PTR(keyBuffer); - SELF_FREE_PTR(dsa, DSA_free); return HKS_ERROR_CRYPTO_ENGINE_ERROR; } dsaPublicKey->size = totalSize; dsaPublicKey->data = keyBuffer; - SELF_FREE_PTR(dsa, DSA_free); + return HKS_SUCCESS; +} +#endif + +#ifdef HKS_SUPPORT_DH_C +static int32_t X509PublicKeyToDh(EVP_PKEY *pkey, struct HksBlob *dhPublicKey) +{ + DH *dh = EVP_PKEY_get0_DH(pkey); + if (dh == NULL) { + HKS_LOG_E("EVP_PKEY_get0_DH error %s", ERR_reason_error_string(ERR_get_error())); + return HKS_ERROR_NULL_POINTER; + } + + const BIGNUM *pubKey = DH_get0_pub_key(dh); + uint32_t pubKeySize = BN_num_bytes(pubKey); + + uint8_t *keyBuffer = HksMalloc(sizeof(struct KeyMaterialDh) + pubKeySize); + if (keyBuffer == NULL) { + HKS_LOG_E("alloc keyBuffer failed"); + return HKS_ERROR_MALLOC_FAIL; + } + struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)keyBuffer; + keyMaterial->keyAlg = HKS_ALG_DH; + keyMaterial->keySize = DH_bits(dh); + keyMaterial->pubKeySize = pubKeySize; + keyMaterial->priKeySize = 0; + keyMaterial->reserved = 0; + + BN_bn2bin(pubKey, keyBuffer + sizeof(struct KeyMaterialDh)); + + dhPublicKey->size = pubKeySize; + dhPublicKey->data = keyBuffer; + return HKS_SUCCESS; } #endif @@ -557,6 +666,12 @@ int32_t TranslateFromX509PublicKey(const struct HksBlob *x509Key, struct HksBlob ret = X509PublicKeyToDsa(pkey, publicKey); #else ret = HKS_ERROR_INVALID_ALGORITHM; +#endif + } else if (keyType == EVP_PKEY_DH) { +#ifdef HKS_SUPPORT_DH_C + ret = X509PublicKeyToDh(pkey, publicKey); +#else + ret = HKS_ERROR_INVALID_ALGORITHM; #endif } else { HKS_LOG_E("Unsupport alg type!"); diff --git a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c index 1153104e..b09fa1ee 100755 --- a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c +++ b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator.c @@ -31,7 +31,7 @@ #include "hks_log.h" #include "hks_mem.h" -int32_t HksGetFileName(const char *path, const char *fileName, char *fullFileName, uint32_t fullFileNameLen) +static int32_t GetFileName(const char *path, const char *fileName, char *fullFileName, uint32_t fullFileNameLen) { if (path != NULL) { if (strncpy_s(fullFileName, fullFileNameLen, path, strlen(path)) != EOK) { @@ -65,7 +65,7 @@ static int32_t GetFullFileName(const char *path, const char *fileName, char **fu } (void)memset_s(tmpFileName, nameLen, 0, nameLen); - int32_t ret = HksGetFileName(path, fileName, tmpFileName, nameLen); + int32_t ret = GetFileName(path, fileName, tmpFileName, nameLen); if (ret != HKS_SUCCESS) { HKS_LOG_E("get full fileName failed"); HKS_FREE_PTR(tmpFileName); @@ -386,3 +386,7 @@ uint32_t HksFileSize(const char *path, const char *fileName) return size; } +int32_t HksGetFileName(const char *path, const char *fileName, char *fullFileName, uint32_t fullFileNameLen) +{ + return GetFileName(path, fileName, fullFileName, fullFileNameLen); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c index f4a7dd86..feebca84 100644 --- a/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c +++ b/services/huks_standard/huks_service/main/os_dependency/posix/hks_file_operator_lite.c @@ -490,4 +490,9 @@ bool HksOldVersionIsFileExist(const char *fileName) } #endif +int32_t HksGetFileName(const char *path, const char *fileName, char *fullFileName, uint32_t fullFileNameLen) +{ + return GetFileName(path, fileName, fullFileName, fullFileNameLen); +} + #endif /* _CUT_AUTHENTICATE_ */ -- Gitee From fffdded0130cb2cc0bd306e35682cd24a60da694 Mon Sep 17 00:00:00 2001 From: zhao-zhen-zhou Date: Tue, 30 Nov 2021 14:37:12 +0800 Subject: [PATCH 09/12] =?UTF-8?q?=E4=BF=AE=E6=94=B9tdd=E7=94=A8=E4=BE=8B?= =?UTF-8?q?=E7=9A=84level=E7=AD=89=E7=BA=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhao-zhen-zhou --- .../test/unittest/src/hks_aes_test.cpp | 6 ++-- .../test/unittest/src/hks_agreement_test.cpp | 2 +- .../test/unittest/src/hks_bn_exp_mod_test.cpp | 2 +- .../test/unittest/src/hks_cipher_test.cpp | 24 ++++++++-------- .../test/unittest/src/hks_curve25519_test.cpp | 8 +++--- .../test/unittest/src/hks_delete_test.cpp | 2 +- .../test/unittest/src/hks_derive_test.cpp | 4 +-- .../test/unittest/src/hks_exist_test.cpp | 2 +- .../unittest/src/hks_generate_key_test.cpp | 2 +- .../unittest/src/hks_generate_random_test.cpp | 2 +- .../test/unittest/src/hks_hash_test.cpp | 2 +- .../test/unittest/src/hks_inner_test.cpp | 28 +++++++++---------- .../test/unittest/src/hks_mac_test.cpp | 4 +-- .../test/unittest/src/hks_modify_key_test.cpp | 2 +- .../test/unittest/src/hks_others_test.cpp | 16 +++++------ .../unittest/src/hks_safe_cipher_key_test.cpp | 2 +- .../src/hks_safe_compare_key_test.cpp | 2 +- .../src/liteos_a_adapter/hks_aes_test.cpp | 8 +++--- .../liteos_a_adapter/hks_agreement_test.cpp | 4 +-- .../liteos_a_adapter/hks_bn_exp_mod_test.cpp | 2 +- .../src/liteos_a_adapter/hks_cipher_test.cpp | 24 ++++++++-------- .../liteos_a_adapter/hks_curve25519_test.cpp | 8 +++--- .../src/liteos_a_adapter/hks_delete_test.cpp | 2 +- .../src/liteos_a_adapter/hks_derive_test.cpp | 4 +-- .../src/liteos_a_adapter/hks_exist_test.cpp | 2 +- .../hks_generate_key_test.cpp | 2 +- .../hks_generate_random_test.cpp | 2 +- .../src/liteos_a_adapter/hks_hash_test.cpp | 2 +- .../src/liteos_a_adapter/hks_mac_test.cpp | 4 +-- .../liteos_a_adapter/hks_modify_key_test.cpp | 2 +- .../src/liteos_a_adapter/hks_others_test.cpp | 16 +++++------ .../hks_safe_cipher_key_test.cpp | 2 +- .../hks_safe_compare_key_test.cpp | 2 +- 33 files changed, 98 insertions(+), 98 deletions(-) diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_aes_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_aes_test.cpp index f124d62a..33ab6008 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_aes_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_aes_test.cpp @@ -55,7 +55,7 @@ void HksAesTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree() == 0); } @@ -65,7 +65,7 @@ HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree1() == 0); } @@ -75,7 +75,7 @@ HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree2() == 0); } diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_agreement_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_agreement_test.cpp index 15c49f69..853a346f 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_agreement_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_agreement_test.cpp @@ -95,7 +95,7 @@ static int32_t AgreeKey(const struct HksTestAgreeParamSet *agreeParamSetParams, * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level1) +HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level0) { /* 1. generate key */ struct HksBlob *privateKey = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_bn_exp_mod_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_bn_exp_mod_test.cpp index 5f29d8b0..f0268489 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_bn_exp_mod_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_bn_exp_mod_test.cpp @@ -95,7 +95,7 @@ static int32_t TestValue() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksBnExpModTest, HksBnExpModTest001, TestSize.Level1) +HWTEST_F(HksBnExpModTest, HksBnExpModTest001, TestSize.Level0) { int32_t ret; if (g_testBnExpModParams[0].isTestValue) { diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_cipher_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_cipher_test.cpp index e8712309..35bcc300 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_cipher_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_cipher_test.cpp @@ -55,62 +55,62 @@ void HksCipherTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCipherTest, HksCipherTest001, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest001, TestSize.Level0) { ASSERT_TRUE(BaseTestCipher(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest002, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest002, TestSize.Level0) { ASSERT_TRUE(BaseTestCipher(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest003, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest003, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest004, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest004, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest005, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest005, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 2, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest006, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest006, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 3, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest007, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest007, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 4, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest008, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest008, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest009, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest009, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest010, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest010, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 2, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest011, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest011, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 3, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest012, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest012, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 4, 1) == 0); } diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_curve25519_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_curve25519_test.cpp index 43587832..0a41d0ec 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_curve25519_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_curve25519_test.cpp @@ -55,7 +55,7 @@ void HksCurve25519Test::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level0) { ASSERT_TRUE(TestCurve25519All() == 0); } @@ -65,7 +65,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level0) { ASSERT_TRUE(TestEd25519SignTeeVerifyLocal() == 0); } @@ -75,7 +75,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level0) { ASSERT_TRUE(TestCurve25519SignWrong() == 0); } @@ -85,7 +85,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test004, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test004, TestSize.Level0) { ASSERT_TRUE(TestCurve25519verifyWrong() == 0); } diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_delete_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_delete_test.cpp index 590db98a..6f13446c 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_delete_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_delete_test.cpp @@ -63,7 +63,7 @@ static const struct HksTestKeyExistParams g_testKeyExistParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeleteTest, HksDeleteTest001, TestSize.Level1) +HWTEST_F(HksDeleteTest, HksDeleteTest001, TestSize.Level0) { int32_t ret; struct HksBlob *keyAlias = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_derive_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_derive_test.cpp index e22c75c8..3c3a664c 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_derive_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_derive_test.cpp @@ -201,7 +201,7 @@ static int32_t BaseTestDerive(uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level1) +HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level0) { int32_t ret = BaseTestDerive(0); ASSERT_TRUE(ret == 0); @@ -212,7 +212,7 @@ HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeriveTest, HksDeriveTest002, TestSize.Level1) +HWTEST_F(HksDeriveTest, HksDeriveTest002, TestSize.Level0) { int32_t ret = BaseTestDerive(1); ASSERT_TRUE(ret == 0); diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_exist_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_exist_test.cpp index 0947b209..a77884dc 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_exist_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_exist_test.cpp @@ -63,7 +63,7 @@ static const struct HksTestKeyExistParams g_testKeyExistParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksExistTest, HksExistTest001, TestSize.Level1) +HWTEST_F(HksExistTest, HksExistTest001, TestSize.Level0) { int32_t ret; struct HksBlob *keyAlias = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_key_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_key_test.cpp index 7d90af02..603080b0 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_key_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_key_test.cpp @@ -74,7 +74,7 @@ static const struct HksTestGenKeyParams g_testGenKeyParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksGenerateKeyTest, HksGenerateKeyTest001, TestSize.Level1) +HWTEST_F(HksGenerateKeyTest, HksGenerateKeyTest001, TestSize.Level0) { uint32_t times = 1; uint32_t index = 0; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_random_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_random_test.cpp index 1fc293fd..80581908 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_random_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_generate_random_test.cpp @@ -62,7 +62,7 @@ static const struct HksTestGenRandomParams g_testGenRandomParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksGenerateRandomTest, HksGenerateRandomTest001, TestSize.Level1) +HWTEST_F(HksGenerateRandomTest, HksGenerateRandomTest001, TestSize.Level0) { int32_t ret; struct HksBlob *random = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_hash_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_hash_test.cpp index 9b4136a4..a181adf9 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_hash_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_hash_test.cpp @@ -70,7 +70,7 @@ static const struct HksTestHashParams g_testHashParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksHashTest, HksHashTest001, TestSize.Level1) +HWTEST_F(HksHashTest, HksHashTest001, TestSize.Level0) { struct HksParamSet *paramSet = NULL; struct HksBlob *srcData = NULL; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_inner_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_inner_test.cpp index 3db60afc..6009b2e8 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_inner_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_inner_test.cpp @@ -33,7 +33,7 @@ class HksInnerTest : public testing::Test {}; * @tc.desc: CheckPurposeValid HMAC & DSA algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest001, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest001, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; ret = HksCheckGenKeyPurpose(HKS_ALG_HMAC, HKS_KEY_PURPOSE_MAC); @@ -47,7 +47,7 @@ HWTEST_F(HksInnerTest, HksInnerTest001, Function | SmallTest | Level1) * @tc.desc: InitInputParamsByAlg HMAC & DSA algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest002, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest002, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; ret = HksGetInputParmasByAlg(HKS_ALG_HMAC, HKS_CHECK_TYPE_GEN_KEY, NULL, NULL); @@ -59,7 +59,7 @@ HWTEST_F(HksInnerTest, HksInnerTest002, Function | SmallTest | Level1) * @tc.desc: GetExpectParams HMAC & DSA algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest003, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest003, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; ParamsValues values = {0, 0, 0, 0, 0}; @@ -72,7 +72,7 @@ HWTEST_F(HksInnerTest, HksInnerTest003, Function | SmallTest | Level1) * @tc.desc: CheckAesPadding CTR & ECB mode * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest004, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest004, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; ParamsValues values = { @@ -92,7 +92,7 @@ HWTEST_F(HksInnerTest, HksInnerTest004, Function | SmallTest | Level1) * @tc.desc: CheckImportMutableParams CTR & ECB mode * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest005, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest005, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; ret = CheckImportMutableParams(HKS_ALG_AES, NULL); @@ -122,7 +122,7 @@ HWTEST_F(HksInnerTest, HksInnerTest005, Function | SmallTest | Level1) * @tc.desc: CheckImportKeySize DSA algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest006, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest006, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; @@ -169,7 +169,7 @@ HWTEST_F(HksInnerTest, HksInnerTest006, Function | SmallTest | Level1) * @tc.desc: CheckImportKeySize DSA algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest007, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest007, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; @@ -218,7 +218,7 @@ HWTEST_F(HksInnerTest, HksInnerTest007, Function | SmallTest | Level1) * @tc.desc: HksLocalCheckCipherParams AES RSA algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest008, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest008, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; @@ -251,7 +251,7 @@ HWTEST_F(HksInnerTest, HksInnerTest008, Function | SmallTest | Level1) * @tc.desc: HksGetDigestLen sha1 sha224 digest * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest009, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest009, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; uint32_t len; @@ -264,7 +264,7 @@ HWTEST_F(HksInnerTest, HksInnerTest009, Function | SmallTest | Level1) * @tc.desc: HksFormatKeyFromMaterial AES RSA HMAC DSA ECC algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest010, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest010, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; uint32_t len; @@ -281,7 +281,7 @@ HWTEST_F(HksInnerTest, HksInnerTest010, Function | SmallTest | Level1) * @tc.desc: HksFormatKeyFromMaterial AES RSA HMAC DSA ECC algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest011, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest011, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; uint32_t len; @@ -298,7 +298,7 @@ HWTEST_F(HksInnerTest, HksInnerTest011, Function | SmallTest | Level1) * @tc.desc: CheckLocalGenerateKeyParams function * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest012, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest012, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; @@ -343,7 +343,7 @@ HWTEST_F(HksInnerTest, HksInnerTest012, Function | SmallTest | Level1) * @tc.desc: CheckLocalCipherParams AES RSA algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest013, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest013, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; @@ -381,7 +381,7 @@ HWTEST_F(HksInnerTest, HksInnerTest013, Function | SmallTest | Level1) * @tc.desc: TranslateToX509PublicKey and TranslateFromX509PublicKey DSA algrithom * @tc.type: FUNC */ -HWTEST_F(HksInnerTest, HksInnerTest014, Function | SmallTest | Level1) +HWTEST_F(HksInnerTest, HksInnerTest014, Function | SmallTest | Level0) { int32_t ret = HKS_SUCCESS; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_mac_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_mac_test.cpp index 6e57e1c5..501d4322 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_mac_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_mac_test.cpp @@ -181,7 +181,7 @@ static int32_t BaseTestMac(uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level1) +HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level0) { int32_t ret = BaseTestMac(0); ASSERT_TRUE(ret == 0); @@ -192,7 +192,7 @@ HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksMacTest, HksMacTest002, TestSize.Level1) +HWTEST_F(HksMacTest, HksMacTest002, TestSize.Level0) { int32_t ret = BaseTestMac(1); ASSERT_TRUE(ret == 0); diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_modify_key_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_modify_key_test.cpp index 7e68aadb..b5f73050 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_modify_key_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_modify_key_test.cpp @@ -302,7 +302,7 @@ int32_t BaseTestCipher(struct HksBlob *keyAlias, uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksModifyKeyTest, HksModifyKeyTest001, TestSize.Level1) +HWTEST_F(HksModifyKeyTest, HksModifyKeyTest001, TestSize.Level0) { uint32_t index = 0; struct HksBlob keyAlias = { strlen(g_testName), (uint8_t *)g_testName }; diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_others_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_others_test.cpp index f0c9ae90..ba3ecfb2 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_others_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_others_test.cpp @@ -55,7 +55,7 @@ void HksOthersTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level0) { int32_t ret = HksGetKeyParamSet(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -66,7 +66,7 @@ HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level0) { int32_t ret = HksGetKeyInfoList(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -77,7 +77,7 @@ HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level0) { int32_t ret = HksAttestKey(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -88,7 +88,7 @@ HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level0) { int32_t ret = HksGetCertificateChain(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -99,7 +99,7 @@ HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level0) { int32_t ret = HksWrapKey(NULL, NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -110,7 +110,7 @@ HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level0) { int32_t ret = HksUnwrapKey(NULL, NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -121,7 +121,7 @@ HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level0) { int32_t ret = HksGetSdkVersion(NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -132,7 +132,7 @@ HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest008, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest008, TestSize.Level0) { int32_t ret = HksInitialize(); ASSERT_TRUE(ret == HKS_SUCCESS); diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_cipher_key_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_cipher_key_test.cpp index c537aa21..b32b7ca8 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_cipher_key_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_cipher_key_test.cpp @@ -84,7 +84,7 @@ static int32_t CompareTwoKey(const struct HksBlob *keyAliasOne, const struct Hks * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksSafeCipherKeyTest, HksSafeCipherKeyTest001, TestSize.Level1) +HWTEST_F(HksSafeCipherKeyTest, HksSafeCipherKeyTest001, TestSize.Level0) { struct HksBlob ed25519Alias = { strlen(g_testEd25519), (uint8_t *)g_testEd25519 }; int32_t ret = TestGenerateEd25519Key(ed25519Alias); diff --git a/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_compare_key_test.cpp b/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_compare_key_test.cpp index bc4a081b..e476ad8d 100755 --- a/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_compare_key_test.cpp +++ b/interfaces/innerkits/huks_standard/test/unittest/src/hks_safe_compare_key_test.cpp @@ -143,7 +143,7 @@ static int32_t CompareKeyData(struct HksBlob *keyAliasOne, struct HksBlob *keyAl * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksSafeCompareKeyTest, HksSafeCompareKeyTest001, TestSize.Level1) +HWTEST_F(HksSafeCompareKeyTest, HksSafeCompareKeyTest001, TestSize.Level0) { struct HksBlob keyAliasOne = { strlen(g_testOne), (uint8_t *)g_testOne }; int32_t ret = SafeTestGenerateKey(&keyAliasOne); diff --git a/test/unittest/src/liteos_a_adapter/hks_aes_test.cpp b/test/unittest/src/liteos_a_adapter/hks_aes_test.cpp index 4dcc6d88..dfd9fe45 100644 --- a/test/unittest/src/liteos_a_adapter/hks_aes_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_aes_test.cpp @@ -57,7 +57,7 @@ void HksAesTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree() == 0); } @@ -67,7 +67,7 @@ HWTEST_F(HksAesTest, HksAesTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree1() == 0); } @@ -77,7 +77,7 @@ HWTEST_F(HksAesTest, HksAesTest002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level0) { ASSERT_TRUE(TestAes256ByAgree2() == 0); } @@ -88,7 +88,7 @@ HWTEST_F(HksAesTest, HksAesTest003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAesTest, HksAesTest004, TestSize.Level1) +HWTEST_F(HksAesTest, HksAesTest004, TestSize.Level0) { ASSERT_EQ(TestAes256ByLocal(), 0); } diff --git a/test/unittest/src/liteos_a_adapter/hks_agreement_test.cpp b/test/unittest/src/liteos_a_adapter/hks_agreement_test.cpp index 14460dc1..914fe48d 100644 --- a/test/unittest/src/liteos_a_adapter/hks_agreement_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_agreement_test.cpp @@ -98,7 +98,7 @@ static int32_t AgreeKey(const struct HksTestAgreeParamSet *agreeParamSetParams, * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level1) +HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level0) { /* 1. generate key */ struct HksBlob *privateKey = NULL; @@ -147,7 +147,7 @@ HWTEST_F(HksAgreementTest, HksAgreementTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksAgreementTest, HksAgreementTest002, TestSize.Level1) +HWTEST_F(HksAgreementTest, HksAgreementTest002, TestSize.Level0) { /* 1. generate key */ struct HksBlob *privateKey = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_bn_exp_mod_test.cpp b/test/unittest/src/liteos_a_adapter/hks_bn_exp_mod_test.cpp index fa182c31..e818517b 100644 --- a/test/unittest/src/liteos_a_adapter/hks_bn_exp_mod_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_bn_exp_mod_test.cpp @@ -96,7 +96,7 @@ static int32_t TestValue() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksBnExpModTest, HksBnExpModTest001, TestSize.Level1) +HWTEST_F(HksBnExpModTest, HksBnExpModTest001, TestSize.Level0) { int32_t ret; if (g_testBnExpModParams[0].isTestValue) { diff --git a/test/unittest/src/liteos_a_adapter/hks_cipher_test.cpp b/test/unittest/src/liteos_a_adapter/hks_cipher_test.cpp index 22de5c8e..bc8816ea 100644 --- a/test/unittest/src/liteos_a_adapter/hks_cipher_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_cipher_test.cpp @@ -56,63 +56,63 @@ void HksCipherTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCipherTest, HksCipherTest001, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest001, TestSize.Level0) { ASSERT_TRUE(BaseTestCipher(1, 0, 1) == 0); } #ifndef _CUT_AUTHENTICATE_ -HWTEST_F(HksCipherTest, HksCipherTest002, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest002, TestSize.Level0) { ASSERT_TRUE(BaseTestCipher(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest003, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest003, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest004, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest004, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest005, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest005, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 2, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest006, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest006, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 3, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest007, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest007, TestSize.Level0) { ASSERT_TRUE(BaseTestEncrypt(1, 4, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest008, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest008, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 0, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest009, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest009, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 1, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest010, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest010, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 2, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest011, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest011, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 3, 1) == 0); } -HWTEST_F(HksCipherTest, HksCipherTest012, TestSize.Level1) +HWTEST_F(HksCipherTest, HksCipherTest012, TestSize.Level0) { ASSERT_TRUE(BaseTestDecrypt(1, 4, 1) == 0); } diff --git a/test/unittest/src/liteos_a_adapter/hks_curve25519_test.cpp b/test/unittest/src/liteos_a_adapter/hks_curve25519_test.cpp index 13bd2c35..e2d14272 100644 --- a/test/unittest/src/liteos_a_adapter/hks_curve25519_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_curve25519_test.cpp @@ -57,7 +57,7 @@ void HksCurve25519Test::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level0) { ASSERT_TRUE(TestCurve25519All() == 0); } @@ -67,7 +67,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level0) { ASSERT_TRUE(TestEd25519SignTeeVerifyLocal() == 0); } @@ -77,7 +77,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level0) { ASSERT_TRUE(TestCurve25519SignWrong() == 0); } @@ -87,7 +87,7 @@ HWTEST_F(HksCurve25519Test, HksCurve25519Test003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksCurve25519Test, HksCurve25519Test004, TestSize.Level1) +HWTEST_F(HksCurve25519Test, HksCurve25519Test004, TestSize.Level0) { ASSERT_TRUE(TestCurve25519verifyWrong() == 0); } diff --git a/test/unittest/src/liteos_a_adapter/hks_delete_test.cpp b/test/unittest/src/liteos_a_adapter/hks_delete_test.cpp index db5c8341..a3c3b339 100644 --- a/test/unittest/src/liteos_a_adapter/hks_delete_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_delete_test.cpp @@ -65,7 +65,7 @@ const struct HksTestKeyExistParams g_testKeyExistParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeleteTest, HksDeleteTest001, TestSize.Level1) +HWTEST_F(HksDeleteTest, HksDeleteTest001, TestSize.Level0) { int32_t ret; struct HksBlob *keyAlias = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_derive_test.cpp b/test/unittest/src/liteos_a_adapter/hks_derive_test.cpp index 2f0f33a8..7532c899 100644 --- a/test/unittest/src/liteos_a_adapter/hks_derive_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_derive_test.cpp @@ -203,7 +203,7 @@ static int32_t BaseTestDerive(uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level1) +HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level0) { int32_t ret = BaseTestDerive(0); ASSERT_TRUE(ret == 0); @@ -215,7 +215,7 @@ HWTEST_F(HksDeriveTest, HksDeriveTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksDeriveTest, HksDeriveTest002, TestSize.Level1) +HWTEST_F(HksDeriveTest, HksDeriveTest002, TestSize.Level0) { int32_t ret = BaseTestDerive(1); ASSERT_TRUE(ret == 0); diff --git a/test/unittest/src/liteos_a_adapter/hks_exist_test.cpp b/test/unittest/src/liteos_a_adapter/hks_exist_test.cpp index d347851e..a993a447 100644 --- a/test/unittest/src/liteos_a_adapter/hks_exist_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_exist_test.cpp @@ -65,7 +65,7 @@ const struct HksTestKeyExistParams g_testKeyExistParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksExistTest, HksExistTest001, TestSize.Level1) +HWTEST_F(HksExistTest, HksExistTest001, TestSize.Level0) { int32_t ret; struct HksBlob *keyAlias = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_generate_key_test.cpp b/test/unittest/src/liteos_a_adapter/hks_generate_key_test.cpp index 43894c0e..16238f30 100644 --- a/test/unittest/src/liteos_a_adapter/hks_generate_key_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_generate_key_test.cpp @@ -76,7 +76,7 @@ const struct HksTestGenKeyParams g_testGenKeyParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksGenerateKeyTest, HksGenerateKeyTest001, TestSize.Level1) +HWTEST_F(HksGenerateKeyTest, HksGenerateKeyTest001, TestSize.Level0) { uint32_t times = 1; uint32_t index = 0; diff --git a/test/unittest/src/liteos_a_adapter/hks_generate_random_test.cpp b/test/unittest/src/liteos_a_adapter/hks_generate_random_test.cpp index f5ad2e91..80f716c1 100644 --- a/test/unittest/src/liteos_a_adapter/hks_generate_random_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_generate_random_test.cpp @@ -63,7 +63,7 @@ const struct HksTestGenRandomParams g_testGenRandomParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksGenerateRandomTest, HksGenerateRandomTest001, TestSize.Level1) +HWTEST_F(HksGenerateRandomTest, HksGenerateRandomTest001, TestSize.Level0) { int32_t ret; struct HksBlob *random = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_hash_test.cpp b/test/unittest/src/liteos_a_adapter/hks_hash_test.cpp index 4e457513..67abaa03 100644 --- a/test/unittest/src/liteos_a_adapter/hks_hash_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_hash_test.cpp @@ -73,7 +73,7 @@ const struct HksTestHashParams g_testHashParams[] = { * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksHashTest, HksHashTest001, TestSize.Level1) +HWTEST_F(HksHashTest, HksHashTest001, TestSize.Level0) { struct HksParamSet *paramSet = NULL; struct HksBlob *srcData = NULL; diff --git a/test/unittest/src/liteos_a_adapter/hks_mac_test.cpp b/test/unittest/src/liteos_a_adapter/hks_mac_test.cpp index f590c65c..593a7970 100644 --- a/test/unittest/src/liteos_a_adapter/hks_mac_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_mac_test.cpp @@ -182,7 +182,7 @@ static int32_t BaseTestMac(uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level1) +HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level0) { int32_t ret = BaseTestMac(0); ASSERT_TRUE(ret == 0); @@ -194,7 +194,7 @@ HWTEST_F(HksMacTest, HksMacTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksMacTest, HksMacTest002, TestSize.Level1) +HWTEST_F(HksMacTest, HksMacTest002, TestSize.Level0) { int32_t ret = BaseTestMac(1); ASSERT_TRUE(ret == 0); diff --git a/test/unittest/src/liteos_a_adapter/hks_modify_key_test.cpp b/test/unittest/src/liteos_a_adapter/hks_modify_key_test.cpp index 2b099954..51ef5b99 100644 --- a/test/unittest/src/liteos_a_adapter/hks_modify_key_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_modify_key_test.cpp @@ -307,7 +307,7 @@ int32_t BaseTestCipherProcess(struct HksBlob *keyAlias, uint32_t index) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksModifyKeyTest, HksModifyKeyTest001, TestSize.Level1) +HWTEST_F(HksModifyKeyTest, HksModifyKeyTest001, TestSize.Level0) { uint32_t index = 0; struct HksBlob keyAlias = { strlen(g_testName), (uint8_t *)g_testName }; diff --git a/test/unittest/src/liteos_a_adapter/hks_others_test.cpp b/test/unittest/src/liteos_a_adapter/hks_others_test.cpp index 359c2168..8449fc6a 100644 --- a/test/unittest/src/liteos_a_adapter/hks_others_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_others_test.cpp @@ -57,7 +57,7 @@ void HksOthersTest::TearDown() * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level0) { int32_t ret = HksGetKeyParamSet(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -68,7 +68,7 @@ HWTEST_F(HksOthersTest, HksOthersTest001, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level0) { int32_t ret = HksGetKeyInfoList(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -79,7 +79,7 @@ HWTEST_F(HksOthersTest, HksOthersTest002, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level0) { int32_t ret = HksAttestKey(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -90,7 +90,7 @@ HWTEST_F(HksOthersTest, HksOthersTest003, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level0) { int32_t ret = HksGetCertificateChain(NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -101,7 +101,7 @@ HWTEST_F(HksOthersTest, HksOthersTest004, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level0) { int32_t ret = HksWrapKey(NULL, NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -112,7 +112,7 @@ HWTEST_F(HksOthersTest, HksOthersTest005, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level0) { int32_t ret = HksUnwrapKey(NULL, NULL, NULL, NULL); ASSERT_TRUE(ret == HKS_ERROR_NOT_SUPPORTED); @@ -123,7 +123,7 @@ HWTEST_F(HksOthersTest, HksOthersTest006, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level0) { int32_t ret = HksGetSdkVersion(NULL); ASSERT_TRUE(ret == HKS_ERROR_NULL_POINTER); @@ -134,7 +134,7 @@ HWTEST_F(HksOthersTest, HksOthersTest007, TestSize.Level1) * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksOthersTest, HksOthersTest008, TestSize.Level1) +HWTEST_F(HksOthersTest, HksOthersTest008, TestSize.Level0) { int32_t ret = HksInitialize(); ASSERT_TRUE(ret == HKS_SUCCESS); diff --git a/test/unittest/src/liteos_a_adapter/hks_safe_cipher_key_test.cpp b/test/unittest/src/liteos_a_adapter/hks_safe_cipher_key_test.cpp index b670ac89..d10edc11 100644 --- a/test/unittest/src/liteos_a_adapter/hks_safe_cipher_key_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_safe_cipher_key_test.cpp @@ -84,7 +84,7 @@ static int32_t CompareTwoKey(const struct HksBlob *keyAliasOne, const struct Hks * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksSafeCipherKeyTest, HksSafeCipherKeyTest001, TestSize.Level1) +HWTEST_F(HksSafeCipherKeyTest, HksSafeCipherKeyTest001, TestSize.Level0) { struct HksBlob ed25519Alias = { strlen(g_testEd25519), (uint8_t *)g_testEd25519 }; int32_t ret = TestGenerateEd25519Key(ed25519Alias); diff --git a/test/unittest/src/liteos_a_adapter/hks_safe_compare_key_test.cpp b/test/unittest/src/liteos_a_adapter/hks_safe_compare_key_test.cpp index b0309605..7ff0129c 100644 --- a/test/unittest/src/liteos_a_adapter/hks_safe_compare_key_test.cpp +++ b/test/unittest/src/liteos_a_adapter/hks_safe_compare_key_test.cpp @@ -147,7 +147,7 @@ static int32_t CompareKeyData(struct HksBlob *keyAliasOne, struct HksBlob *keyAl * @tc.desc: The static function will return true; * @tc.type: FUNC */ -HWTEST_F(HksSafeCompareKeyTest, HksSafeCompareKeyTest001, TestSize.Level1) +HWTEST_F(HksSafeCompareKeyTest, HksSafeCompareKeyTest001, TestSize.Level0) { struct HksBlob keyAliasOne = { strlen(g_testOne), (uint8_t *)g_testOne }; int32_t ret = SafeTestGenerateKey(&keyAliasOne); -- Gitee From 538e6c7b9f57aebf42ef50f018b326b7dd68e079 Mon Sep 17 00:00:00 2001 From: zhao-zhen-zhou Date: Tue, 30 Nov 2021 19:53:51 +0800 Subject: [PATCH 10/12] =?UTF-8?q?=E4=B8=8A=E4=BC=A0hks=5Fca=5Faccess.c?= =?UTF-8?q?=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhao-zhen-zhou --- .../main/os_dependency/ca/hks_ca_access.c | 121 ++++++++++++++++++ .../main/os_dependency/ca/hks_teec.c | 38 ------ .../main/os_dependency/ca/hks_teec.h | 5 - 3 files changed, 121 insertions(+), 43 deletions(-) create mode 100755 services/huks_standard/huks_service/main/os_dependency/ca/hks_ca_access.c diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_ca_access.c b/services/huks_standard/huks_service/main/os_dependency/ca/hks_ca_access.c new file mode 100755 index 00000000..dbcf2523 --- /dev/null +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_ca_access.c @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifdef HKS_CONFIG_FILE +#include HKS_CONFIG_FILE +#else +#include "hks_config.h" +#endif + +#include "hks_access.h" +#include "hks_teec.h" + +int32_t HksAccessInitialize(void) +{ + return HKS_ERROR_NOT_SUPPORTED; +} + +int32_t HksAccessRefresh(void) +{ + return HKS_ERROR_NOT_SUPPORTED; +} + +int32_t HksAccessGenerateKey(const struct HksBlob *keyBlob, const struct HksParamSet *paramSetIn, + const struct HksBlob *keyIn, struct HksBlob *keyOut) +{ + (void)keyIn; + return HksTeeGenerateKey(keyBlob, paramSetIn, keyOut); +} + +int32_t HksAccessSign(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *signature) +{ + return HksTeeSign(key, paramSet, srcData, signature); +} + +int32_t HksAccessVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, const struct HksBlob *signature) +{ + return HksTeeVerify(key, paramSet, srcData, signature); +} + +int32_t HksAccessEncrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *plainText, struct HksBlob *cipherText) +{ + return HksTeeEncrypt(key, paramSet, plainText, cipherText); +} + +int32_t HksAccessDecrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *cipherText, struct HksBlob *plainText) +{ + return HksTeeDecrypt(key, paramSet, cipherText, plainText); +} + +int32_t HksAccessGenerateRandom(const struct HksParamSet *paramSet, struct HksBlob *random) +{ + return HksTeeGenerateRandom(paramSet, random); +} + +int32_t HksAccessImportKey(const struct HksBlob *keyAlias, const struct HksBlob *key, + const struct HksParamSet *paramSet, struct HksBlob *keyOut) +{ + (void)keyAlias; + return HksTeeImportKey(key, paramSet, keyOut); +} + +int32_t HksAccessExportPublicKey(const struct HksBlob *key, const struct HksParamSet *paramSet, + struct HksBlob *keyOut) +{ + return HksTeeExportPublicKey(key, paramSet, keyOut); +} + +int32_t HksAccessAgreeKey(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, + const struct HksBlob *peerPublicKey, struct HksBlob *agreedKey) +{ + return HksTeeAgreeKey(paramSet, privateKey, peerPublicKey, agreedKey); +} + +int32_t HksAccessDeriveKey(const struct HksParamSet *paramSet, const struct HksBlob *kdfKey, + struct HksBlob *derivedKey) +{ + return HksTeeDeriveKey(paramSet, kdfKey, derivedKey); +} + +int32_t HksAccessMac(const struct HksBlob *key, const struct HksParamSet *paramSet, + const struct HksBlob *srcData, struct HksBlob *mac) +{ + return HksTeeMac(key, paramSet, srcData, mac); +} + +int32_t HksAccessCheckKeyValidity(const struct HksParamSet *paramSet, const struct HksBlob *key) +{ + return HksTeeCheckKeyLegality(paramSet, key); +} + +int32_t HksAccessExportTrustCerts(struct HksBlob *certChain) +{ + return HksTeeExportTrustCerts(certChain); +} + +int32_t HksAccessImportTrustCerts(const struct HksBlob *certChain) +{ + return HksTeeImportTrustCerts(certChain); +} + +int32_t HcmAccessIsDeviceKeyExist(const struct HksParamSet *paramSet) +{ + (void)paramSet; + return HcmTeeIsDeviceKeyExist(); +} \ No newline at end of file diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c index 3e61c5f8..70c7a185 100755 --- a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.c @@ -691,44 +691,6 @@ int32_t HksTeeImportTrustCerts(const struct HksBlob *certChain) return ret; } -#ifdef HKS_SUPPORT_API_EXPORT_DEVICE_PRI_KEY_MOD -int32_t HksTeeExportDevPriKey(const struct HksBlob *key, const struct HksParamSet *paramSet, - struct HksBlob *devPriKey) -{ - uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_INPUT, - TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); - struct HksParam params[MAX_TEE_PARAMS_NUMS]; - - InitializeBlob(¶ms[0].blob, key->size, key->data); - InitializeBlob(¶ms[1].blob, paramSet->paramSetSize, (uint8_t *)paramSet); - InitializeBlob(¶ms[2].blob, devPriKey->size, devPriKey->data); /* 2 is array index */ - - TEEC_Operation operation; - int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_EXPORT_DEV_PRIVATE_KEY, &operation); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("Invoke HKS_CMD_ID_EXPORT_DEV_PRIVATE_KEY failed"); - return ret; - } - devPriKey->size = operation.params[2].tmpref.size; /* 2 is array index */ - return ret; -} -#endif - -#ifdef HKS_SUPPORT_API_DELETE_DEVICE_CERTS_MOD -int32_t HksTeeDeleteTrustCerts(void) -{ - uint32_t paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE); - struct HksParam params[MAX_TEE_PARAMS_NUMS] = {0}; - - TEEC_Operation operation; - int32_t ret = HksTeeCommand(paramTypes, params, HKS_CMD_ID_DELETE_TRUST_CERT, &operation); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("Invoke HKS_CMD_ID_DELETE_TRUST_CERT failed"); - } - return ret; -} -#endif - int32_t HcmTeeIsDeviceKeyExist(void) { HKS_LOG_D("enter"); diff --git a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h index ad71a649..2c3a0b12 100755 --- a/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h +++ b/services/huks_standard/huks_service/main/os_dependency/ca/hks_teec.h @@ -77,11 +77,6 @@ int32_t HksTeeExportTrustCerts(struct HksBlob *certChain); int32_t HksTeeImportTrustCerts(const struct HksBlob *certChain); -int32_t HksTeeExportDevPriKey(const struct HksBlob *key, const struct HksParamSet *paramSet, - struct HksBlob *devPriKey); - -int32_t HksTeeDeleteTrustCerts(void); - int32_t HcmTeeIsDeviceKeyExist(void); int32_t HksTeeProvision(const struct HksBlob *keybox, struct HksBlob *challenge, -- Gitee From 8f1aa6a5cf54975de4814b375629534e7bb83602 Mon Sep 17 00:00:00 2001 From: SryLideming Date: Wed, 24 Nov 2021 15:08:19 +0800 Subject: [PATCH 11/12] merage 12,14,15,16,17,18,19,20,21,22 1.Fix code issue in original code; 2.Update UT/MT source code; 3.Add test code for stability; 4.open alg.DH funtion; 5.Add file lock to backup files; Signed-off-by: SryLideming --- .vscode/settings.json | 5 - .../main/common/include/hks_config.h | 6 + .../mbedtls/src/hks_mbedtls_engine.c | 15 + .../mbedtls/src/hks_mbedtls_rsa.c | 4 +- .../openssl/src/hks_openssl_dh.c | 2 +- .../openssl/src/hks_openssl_dsa.c | 3 +- .../openssl/src/hks_openssl_ecc.c | 24 +- .../openssl/src/hks_openssl_rsa.c | 6 +- .../unittest/hks_crypto_hal_aes_cipher.cpp | 1403 +++----- .../unittest/hks_crypto_hal_aes_decrypt.cpp | 1122 ++---- .../unittest/hks_crypto_hal_aes_encrypt.cpp | 1103 ++---- .../test/unittest/hks_crypto_hal_aes_key.cpp | 129 +- .../unittest/hks_crypto_hal_api_mbedtls.cpp | 42 +- .../unittest/hks_crypto_hal_api_openssl.cpp | 50 +- .../test/unittest/hks_crypto_hal_dh.cpp | 83 +- .../test/unittest/hks_crypto_hal_dh_agree.cpp | 182 +- .../test/unittest/hks_crypto_hal_dsa_key.cpp | 14 +- .../test/unittest/hks_crypto_hal_dsa_sign.cpp | 322 +- .../test/unittest/hks_crypto_hal_ecc_key.cpp | 166 +- .../unittest/hks_crypto_hal_ecdh_agree.cpp | 264 +- .../unittest/hks_crypto_hal_ecdsa_sign.cpp | 1392 +++----- .../unittest/hks_crypto_hal_hmac_hmac.cpp | 226 +- .../test/unittest/hks_crypto_hal_hmac_key.cpp | 12 +- .../unittest/hks_crypto_hal_rsa_cipher.cpp | 2713 +++++--------- .../unittest/hks_crypto_hal_rsa_decrypt.cpp | 1066 +++--- .../unittest/hks_crypto_hal_rsa_encrypt.cpp | 1046 +++--- .../test/unittest/hks_crypto_hal_rsa_key.cpp | 224 +- .../hks_crypto_hal_rsa_oaep_decrypt.cpp | 3098 +++++++--------- .../hks_crypto_hal_rsa_oaep_encrypt.cpp | 2912 ++++++--------- .../hks_crypto_hal_rsa_pkcs1_sign.cpp | 2400 +++++-------- .../unittest/hks_crypto_hal_rsa_pss_sign.cpp | 1726 ++++----- .../huks_standard/test/moduletest/BUILD.gn | 33 +- .../moduletest/include/hks_rsa_common_mt.h | 156 + ...ssl_aes_test_mt.h => openssl_aes_helper.h} | 15 +- ...enssl_dh_mt_test.h => openssl_dh_helper.h} | 5 +- ...sa_sign_test_mt.h => openssl_dsa_helper.h} | 4 +- ...ssl_ecc_mt_test.h => openssl_ecc_helper.h} | 4 +- ...l_hmac_mt_test.h => openssl_hmac_helper.h} | 4 +- ...ssl_rsa_test_mt.h => openssl_rsa_helper.h} | 6 +- ...pher_mt_test.cpp => hks_aes_cipher_mt.cpp} | 1296 +++---- .../moduletest/src/hks_aes_decrypt_mt.cpp | 686 ++++ .../src/hks_aes_decrypt_mt_test.cpp | 1145 ------ .../moduletest/src/hks_aes_encrypt_mt.cpp | 682 ++++ .../src/hks_aes_encrypt_mt_test.cpp | 1127 ------ .../test/moduletest/src/hks_aes_key_mt.cpp | 678 ++++ .../moduletest/src/hks_aes_key_mt_test.cpp | 1204 ------- .../test/moduletest/src/hks_agree_mt.cpp | 908 +++++ .../test/moduletest/src/hks_agree_mt_test.cpp | 1176 ------ .../test/moduletest/src/hks_dsa_mt.cpp | 1137 ++++++ .../test/moduletest/src/hks_dsa_test_mt.cpp | 1730 --------- .../test/moduletest/src/hks_ecc_key_mt.cpp | 753 ++++ .../moduletest/src/hks_ecc_key_mt_test.cpp | 1497 -------- ...c_sign_mt_test.cpp => hks_ecc_sign_mt.cpp} | 2841 ++++++--------- ...rify_mt_test.cpp => hks_ecc_verify_mt.cpp} | 2888 ++++++--------- .../test/moduletest/src/hks_hmac_mt.cpp | 489 +++ .../test/moduletest/src/hks_hmac_mt_test.cpp | 740 ---- .../test/moduletest/src/hks_rsa_common_mt.cpp | 522 +++ .../src/hks_rsa_ecb_nopadding_mt.cpp | 3163 +++++------------ .../src/hks_rsa_ecb_oaep_padding_mt.cpp | 2743 ++++---------- .../src/hks_rsa_ecb_oaep_sha1_mt.cpp | 2745 ++++---------- .../src/hks_rsa_ecb_oaep_sha224_mt.cpp | 2749 ++++---------- .../src/hks_rsa_ecb_oaep_sha256_mt.cpp | 2519 ++++--------- .../src/hks_rsa_ecb_oaep_sha384_mt.cpp | 2467 ++++--------- .../src/hks_rsa_ecb_oaep_sha512_mt.cpp | 2421 ++++--------- .../src/hks_rsa_ecb_pkcs1_padding_mt.cpp | 2591 ++++---------- .../src/hks_rsa_md5_with_rsa_mt.cpp | 1997 +++-------- .../src/hks_rsa_none_with_rsa_mt.cpp | 1997 +++-------- .../src/hks_rsa_sha1_with_rsa_mt.cpp | 1997 +++-------- .../src/hks_rsa_sha1_with_rsa_pss_mt.cpp | 1997 +++-------- .../src/hks_rsa_sha224_with_rsa_mt.cpp | 1997 +++-------- .../src/hks_rsa_sha224_with_rsa_pss_mt.cpp | 1997 +++-------- .../src/hks_rsa_sha256_with_rsa_mt.cpp | 1997 +++-------- .../src/hks_rsa_sha256_with_rsa_pss_mt.cpp | 1997 +++-------- .../src/hks_rsa_sha384_with_rsa_mt.cpp | 1993 ++++------- .../src/hks_rsa_sha384_with_rsa_pss_mt.cpp | 2013 ++++------- .../src/hks_rsa_sha512_with_rsa_mt.cpp | 1993 ++++------- .../src/hks_rsa_sha512_with_rsa_pss_mt.cpp | 2009 ++++------- ...ssl_aes_test_mt.c => openssl_aes_helper.c} | 96 +- ...enssl_dh_mt_test.c => openssl_dh_helper.c} | 62 +- ...sa_sign_test_mt.c => openssl_dsa_helper.c} | 175 +- ...ssl_ecc_mt_test.c => openssl_ecc_helper.c} | 95 +- ...l_hmac_mt_test.c => openssl_hmac_helper.c} | 5 +- ...ssl_rsa_test_mt.c => openssl_rsa_helper.c} | 180 +- ohos.build | 3 +- .../core/src/hks_client_service_adapter.c | 13 +- .../huks_service/main/core/src/hks_storage.c | 125 +- .../main/os_dependency/sa/hks_sa.cpp | 2 +- .../sa/sa_mgr/hks_samgr_service.c | 4 +- .../sa/sa_mgr/hks_samgr_service_feature.c | 2 +- test/stability/BUILD.gn | 52 + test/stability/src/api_pressure_test.cpp | 1509 ++++++++ test/stability/src/pressure_test.cpp | 1263 +++++++ 92 files changed, 32965 insertions(+), 59489 deletions(-) delete mode 100755 .vscode/settings.json create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/include/hks_rsa_common_mt.h rename interfaces/innerkits/huks_standard/test/moduletest/include/{hks_openssl_aes_test_mt.h => openssl_aes_helper.h} (66%) rename interfaces/innerkits/huks_standard/test/moduletest/include/{hks_openssl_dh_mt_test.h => openssl_dh_helper.h} (93%) rename interfaces/innerkits/huks_standard/test/moduletest/include/{hks_openssl_dsa_sign_test_mt.h => openssl_dsa_helper.h} (94%) rename interfaces/innerkits/huks_standard/test/moduletest/include/{hks_openssl_ecc_mt_test.h => openssl_ecc_helper.h} (96%) rename interfaces/innerkits/huks_standard/test/moduletest/include/{hks_openssl_hmac_mt_test.h => openssl_hmac_helper.h} (94%) rename interfaces/innerkits/huks_standard/test/moduletest/include/{hks_openssl_rsa_test_mt.h => openssl_rsa_helper.h} (95%) rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_aes_cipher_mt_test.cpp => hks_aes_cipher_mt.cpp} (34%) create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt.cpp delete mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt.cpp delete mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt.cpp delete mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt.cpp delete mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_mt.cpp delete mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_test_mt.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt.cpp delete mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt_test.cpp rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_ecc_sign_mt_test.cpp => hks_ecc_sign_mt.cpp} (36%) rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_ecc_verify_mt_test.cpp => hks_ecc_verify_mt.cpp} (35%) create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt.cpp delete mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp create mode 100755 interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_common_mt.cpp rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_openssl_aes_test_mt.c => openssl_aes_helper.c} (83%) rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_openssl_dh_mt_test.c => openssl_dh_helper.c} (87%) rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_openssl_dsa_sign_test_mt.c => openssl_dsa_helper.c} (74%) rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_openssl_ecc_mt_test.c => openssl_ecc_helper.c} (89%) rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_openssl_hmac_mt_test.c => openssl_hmac_helper.c} (94%) rename interfaces/innerkits/huks_standard/test/moduletest/src/{hks_openssl_rsa_test_mt.c => openssl_rsa_helper.c} (72%) create mode 100755 test/stability/BUILD.gn create mode 100755 test/stability/src/api_pressure_test.cpp create mode 100755 test/stability/src/pressure_test.cpp diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100755 index 47aeff71..00000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "files.associations": { - "hks_config.h": "c" - } -} \ No newline at end of file diff --git a/frameworks/huks_standard/main/common/include/hks_config.h b/frameworks/huks_standard/main/common/include/hks_config.h index 6d0b682c..a6aaadec 100644 --- a/frameworks/huks_standard/main/common/include/hks_config.h +++ b/frameworks/huks_standard/main/common/include/hks_config.h @@ -93,6 +93,12 @@ #define HKS_SUPPORT_RSA_ECB_OEAPPADDING #define HKS_SUPPORT_RSA_PSS +/* DH */ +#define HKS_SUPPORT_DH_C +#define HKS_SUPPORT_DH_GENERATE_KEY +#define HKS_SUPPORT_DH_AGREE_KEY +#define HKS_SUPPORT_DH_GET_PUBLIC_KEY + /* DSA */ #define HKS_SUPPORT_DSA_C #define HKS_SUPPORT_DSA_GENERATE_KEY diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c index 6bb1f1f5..e7c0dd22 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_engine.c @@ -80,6 +80,9 @@ static int32_t EncryptCheckParam(const struct HksBlob *key, const struct HksUsag int32_t HksCryptoHalHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, struct HksBlob *mac) { + if (CheckBlob(key) != HKS_SUCCESS || CheckBlob(msg) != HKS_SUCCESS || CheckBlob(mac) != HKS_SUCCESS) { + return HKS_ERROR_INVALID_ARGUMENT; + } #ifdef HKS_SUPPORT_HMAC_C return HksMbedtlsHmac(key, digestAlg, msg, mac); #else @@ -235,6 +238,10 @@ int32_t HksCryptoHalDeriveKey(const struct HksBlob *mainKey, int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, const struct HksKeySpec *spec, struct HksBlob *sharedKey) { + if (CheckBlob(nativeKey) != HKS_SUCCESS || CheckBlob(pubKey) != HKS_SUCCESS || spec == NULL || + CheckBlob(sharedKey) != HKS_SUCCESS) { + return HKS_ERROR_INVALID_ARGUMENT; + } switch (spec->algType) { #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECDH_C) && defined(HKS_SUPPORT_ECDH_AGREE_KEY) case HKS_ALG_ECDH: @@ -261,6 +268,10 @@ int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBl int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature) { + if (CheckBlob(key) != HKS_SUCCESS || usageSpec == NULL || CheckBlob(message) != HKS_SUCCESS || + CheckBlob(signature) != HKS_SUCCESS) { + return HKS_ERROR_INVALID_ARGUMENT; + } switch (usageSpec->algType) { #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) case HKS_ALG_RSA: @@ -283,6 +294,10 @@ int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *u int32_t HksCryptoHalVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const struct HksBlob *signature) { + if (CheckBlob(key) != HKS_SUCCESS || usageSpec == NULL || CheckBlob(message) != HKS_SUCCESS || + CheckBlob(signature) != HKS_SUCCESS) { + return HKS_ERROR_INVALID_ARGUMENT; + } switch (usageSpec->algType) { #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_SIGN_VERIFY) case HKS_ALG_RSA: diff --git a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c index 50847205..9a9365f7 100644 --- a/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c +++ b/frameworks/huks_standard/main/crypto_engine/mbedtls/src/hks_mbedtls_rsa.c @@ -246,7 +246,7 @@ static int32_t RsaKeyMaterialToCtx(const struct HksBlob *key, const bool needPri #endif /* HKS_SUPPORT_RSA_CRYPT or HKS_SUPPORT_RSA_SIGN_VERIFY */ #ifdef HKS_SUPPORT_RSA_CRYPT -int32_t HksToMbedtlsPadding(uint32_t hksPadding, int32_t *padding) +static int32_t HksToMbedtlsPadding(uint32_t hksPadding, int32_t *padding) { switch (hksPadding) { case HKS_PADDING_PKCS1_V1_5: @@ -325,7 +325,7 @@ int32_t HksMbedtlsRsaCrypt(const struct HksBlob *key, const struct HksUsageSpec #endif /* HKS_SUPPORT_RSA_CRYPT */ #ifdef HKS_SUPPORT_RSA_SIGN_VERIFY -int32_t HksToMbedtlsSignPadding(uint32_t hksPadding, int32_t *padding) +static int32_t HksToMbedtlsSignPadding(uint32_t hksPadding, int32_t *padding) { switch (hksPadding) { case HKS_PADDING_PKCS1_V1_5: diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c index 8adc8a06..e23be9c2 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dh.c @@ -192,7 +192,7 @@ int32_t HksOpensslDhAgreeKey(const struct HksBlob *nativeKey, const struct HksBl return HKS_ERROR_CRYPTO_ENGINE_ERROR; } - if (HKS_KEY_BYTES(spec->keyLen) > DH_size(dh)) { + if (HKS_KEY_BYTES(spec->keyLen) > (uint32_t)DH_size(dh)) { ret = HKS_ERROR_INVALID_KEY_SIZE; } else { (void)memcpy_s(sharedKey->data, sharedKey->size, computeKey, HKS_KEY_BYTES(spec->keyLen)); diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c index ae121a28..d734664b 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_dsa.c @@ -55,6 +55,7 @@ static DSA *InitDsaStruct(const struct HksBlob *key, const bool needPrivateExpon BIGNUM *x = NULL; if (needPrivateExponent == true) { if (keyMaterial->xSize == 0) { + DSA_free(dsa); return NULL; } else { (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->xSize); @@ -199,7 +200,7 @@ static int32_t DsaSaveKeyMaterial(const DSA *dsa, const uint32_t keySize, uint8_ int32_t HksOpensslDsaGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key) { int32_t ret; - if (spec->keyLen % HKS_BITS_PER_BYTE != 0) { + if ((spec->keyLen == 0) || (spec->keyLen % HKS_BITS_PER_BYTE != 0)) { return HKS_ERROR_INVALID_ARGUMENT; } diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c index 353747b1..8b9d51c4 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_ecc.c @@ -342,7 +342,7 @@ static int32_t GetEvpKey(const struct HksBlob *keyBlob, EVP_PKEY *key, bool priv return HKS_SUCCESS; } -int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key) +static int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key) { int32_t ret = GetEvpKey(nativeKey, key, true); if (ret != HKS_SUCCESS) { @@ -352,7 +352,7 @@ int32_t GetNativePKey(const struct HksBlob *nativeKey, EVP_PKEY *key) return ret; } -int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key) +static int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key) { int32_t ret = GetEvpKey(pubKey, key, false); if (ret != HKS_SUCCESS) { @@ -362,7 +362,7 @@ int32_t GetPeerKey(const struct HksBlob *pubKey, EVP_PKEY *key) return ret; } -int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedKey) +static int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedKey) { size_t tmpSharedKeySize = (size_t)sharedKey->size; if (EVP_PKEY_derive_init(ctx) != 1) { @@ -378,22 +378,20 @@ int32_t EcdhDerive(EVP_PKEY_CTX *ctx, EVP_PKEY *peerKey, struct HksBlob *sharedK return HKS_FAILURE; } - uint8_t *buffer = (uint8_t *)HksMalloc(tmpSharedKeySize); - if (buffer == NULL) { - HKS_LOG_E("malloc size %u failed", tmpSharedKeySize); - return HKS_ERROR_MALLOC_FAIL; + if (tmpSharedKeySize > sharedKey->size) { + return HKS_ERROR_BUFFER_TOO_SMALL; } - if (EVP_PKEY_derive(ctx, buffer, &tmpSharedKeySize) != 1) { + + if (EVP_PKEY_derive(ctx, sharedKey->data, &tmpSharedKeySize) != 1) { HksLogOpensslError(); - HksFree(sharedKey->data); return HKS_FAILURE; } - sharedKey->size = (uint32_t)tmpSharedKeySize; - sharedKey->data = buffer; + sharedKey->size = tmpSharedKeySize; + return HKS_SUCCESS; } -int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey) +static int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey) { int32_t res = HKS_FAILURE; EVP_PKEY *pKey = EVP_PKEY_new(); @@ -443,6 +441,7 @@ int32_t AgreeKeyEcdh(const struct HksBlob *nativeKey, const struct HksBlob *pubK return res; } +#ifdef HKS_SUPPORT_ECDH_AGREE_KEY int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, const struct HksKeySpec *spec, struct HksBlob *sharedKey) { @@ -458,6 +457,7 @@ int32_t HksOpensslEcdhAgreeKey(const struct HksBlob *nativeKey, const struct Hks return ret; } +#endif static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest, bool sign) { diff --git a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c index 218a2e7f..f21f05ad 100755 --- a/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c +++ b/frameworks/huks_standard/main/crypto_engine/openssl/src/hks_openssl_rsa.c @@ -331,7 +331,7 @@ static int32_t GetRsaSignPadding(uint32_t padding, uint32_t *rsaPadding) } } -static EVP_MD_CTX *InitRSAMdCtx(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool signing) +static EVP_MD_CTX *InitRsaMdCtx(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, bool signing) { int32_t ret = HKS_FAILURE; uint32_t opensslPadding = 0; @@ -397,7 +397,7 @@ static EVP_MD_CTX *InitRSAMdCtx(const struct HksBlob *key, const struct HksUsage int32_t HksOpensslRsaSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, struct HksBlob *signature) { - EVP_MD_CTX *ctx = InitRSAMdCtx(key, usageSpec, true); + EVP_MD_CTX *ctx = InitRsaMdCtx(key, usageSpec, true); if (ctx == NULL) { HKS_LOG_E("initialize rsa md context failed"); return HKS_ERROR_INVALID_KEY_INFO; @@ -437,7 +437,7 @@ int32_t HksOpensslRsaSign(const struct HksBlob *key, const struct HksUsageSpec * int32_t HksOpensslRsaVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, const struct HksBlob *message, const struct HksBlob *signature) { - EVP_MD_CTX *ctx = InitRSAMdCtx(key, usageSpec, false); + EVP_MD_CTX *ctx = InitRsaMdCtx(key, usageSpec, false); if (ctx == NULL) { HKS_LOG_E("initialize rsa md context failed"); return HKS_ERROR_INVALID_KEY_INFO; diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp index 97a34a60..539caf0a 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_cipher.cpp @@ -13,1172 +13,665 @@ * limitations under the License. */ +#include + #include -#include -#include "hks_config.h" #include "hks_crypto_hal.h" #include "hks_crypto_hal_common.h" #include "hks_mem.h" using namespace testing::ext; -namespace AesCipher { +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -const char AES_128_GCM_KEY[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; -const char AES_192_GCM_KEY[] = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; -} // namespace -class HksCryptoHalAesCipher : public HksCryptoHalCommon, public testing::Test {}; - -/** - * @tc.number : HksCryptoHalAesCipher_001 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CBC-NOPADDING key - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_001, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +struct TestCaseParams { + HksKeySpec spec; + HksUsageSpec usageSpec; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[16] = {0}; +const HksCipherParam tagIv = { .iv = { .size = 16, .data = (uint8_t *)IV } }; +const HksAeadParam aeadParam = { + .nonce = { .size = 16, .data = (uint8_t *)IV }, + .aad = { .size = 0, .data = nullptr }, + .tagLenEnc = 16, + .payloadLen = 0, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_001_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_128, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_002 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CBC-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_002, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_002_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_128, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_003 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CTR-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_003, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_003_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_128, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalAesCipher_004 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-128-ECB-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_004, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_004_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_128, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + }, + .hexData = "00112233445566778899aabbccddeeff", - HksBlob tagAead = { .size = 0, .data = nullptr }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_005 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-128-ECB-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_005, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_005_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_128, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - uint32_t inscriptionLen = dataLen; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +}; -/** - * @tc.number : HksCryptoHalAesCipher_006 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-128-GCM-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_006, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_006_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_128, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagLenEnc = 16; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_GCM, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &aeadParam, - }; - - uint32_t dataLen = strlen(AES_128_GCM_KEY) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&AES_128_GCM_KEY[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + .algParam = (void *)&aeadParam, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&AES_128_GCM_KEY[2 * ii]); - } - - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - aeadParam.tagDec = tagAead; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); - HksFree(tagAead.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_007 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CBC-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_007, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_007_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_192, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalAesCipher_008 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CBC-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_008, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_008_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_192, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob tagAead = { .size = 0, .data = nullptr }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_009 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CTR-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_009, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_009_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_192, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_010 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-192-ECB-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_010, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_010_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_192, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + }, + .hexData = "00112233445566778899aabbccddeeff", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_011 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-192-ECB-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_011, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_011_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_192, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +}; -/** - * @tc.number : HksCryptoHalAesCipher_012 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-192-GCM-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_012, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_012_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_192, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagLenEnc = 16; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_GCM, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &aeadParam, - }; - - uint32_t dataLen = strlen(AES_192_GCM_KEY) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&AES_192_GCM_KEY[2 * ii]); - } + .algParam = (void *)&aeadParam, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&AES_192_GCM_KEY[2 * ii]); - } - - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - aeadParam.tagDec = tagAead; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(tagAead.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_013 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CBC-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_013, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_013_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_014 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CBC-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_014, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_014_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_015 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CTR-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_015, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_015_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + .algParam = (void *)&tagIv, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", -/** - * @tc.number : HksCryptoHalAesCipher_016 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-256-ECB-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_016, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_016_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "00112233445566778899aabbccddeeff", - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalAesCipher_017 - * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-256-ECB-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_017, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_017_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - uint32_t inscriptionLen = dataLen; +const TestCaseParams HKS_CRYPTO_HAL_AES_CIPHER_018_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = (void *)&aeadParam, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +class HksCryptoHalAesCipher : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + HksBlob plaintext = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) { + if (testCaseParams.usageSpec.mode == HKS_MODE_GCM) { + struct HksAeadParam aeadParamForGcm; + aeadParamForGcm.nonce = { .size = 16, .data = (uint8_t *)IV }; + aeadParamForGcm.aad = { .size = 0, .data = nullptr }; + aeadParamForGcm.tagDec = tagAead; + aeadParamForGcm.payloadLen = 0; + HksUsageSpec usageSpecForGCM = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParamForGcm, + }; + EXPECT_EQ( + HksCryptoHalDecrypt(&key, &usageSpecForGCM, &cipherText, &plaintext), testCaseParams.decryptResult); + } else { + EXPECT_EQ(HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &cipherText, &plaintext), + testCaseParams.decryptResult); + } + EXPECT_EQ(message.size, plaintext.size); + EXPECT_EQ(HksMemCmp(message.data, plaintext.data, plaintext.size), HKS_SUCCESS); + } + + HksFree(key.data); + HksFree(cipherText.data); + HksFree(plaintext.data); + HksFree(tagAead.data); + } +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +/** + * @tc.number : HksCryptoHalAesCipher_001 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CBC-NOPADDING key + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_001_PARAMS); +} - HksBlob tagAead = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalAesCipher_002 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_002_PARAMS); +} - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalAesCipher_003 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_003_PARAMS); +} - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); -#endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); +/** + * @tc.number : HksCryptoHalAesCipher_004 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_004_PARAMS); } /** - * @tc.number : HksCryptoHalAesCipher_018 + * @tc.number : HksCryptoHalAesCipher_005 * @tc.name : - * @tc.desc : Generate key and Encrypt / Decrypt AES-256-GCM-NOPADDING key. + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-ECB-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_018, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_005, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_AES, - .keyLen = HKS_AES_KEY_SIZE_256, - .algParam = nullptr, - }; + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_005_PARAMS); +} - HksBlob key = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalAesCipher_006 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-128-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_006, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_006_PARAMS); +} - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagLenEnc = 16; +/** + * @tc.number : HksCryptoHalAesCipher_007 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_007, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_007_PARAMS); +} - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_GCM, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &aeadParam, - }; +/** + * @tc.number : HksCryptoHalAesCipher_008 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_008, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_008_PARAMS); +} - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; +/** + * @tc.number : HksCryptoHalAesCipher_009 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_009, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_009_PARAMS); +} - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - uint32_t inscriptionLen = dataLen; +/** + * @tc.number : HksCryptoHalAesCipher_010 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_010, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_010_PARAMS); +} - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalAesCipher_011 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_011, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_012 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-192-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_012, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_012_PARAMS); +} - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +/** + * @tc.number : HksCryptoHalAesCipher_013 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_013, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_013_PARAMS); +} - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; +/** + * @tc.number : HksCryptoHalAesCipher_014 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_014, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_014_PARAMS); +} - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalAesCipher_015 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_015, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_016 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_016, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_016_PARAMS); +} - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - aeadParam.tagDec = tagAead; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); - HksFree(tagAead.data); +/** + * @tc.number : HksCryptoHalAesCipher_017 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_017, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_017_PARAMS); +} + +/** + * @tc.number : HksCryptoHalAesCipher_018 + * @tc.name : + * @tc.desc : Generate key and Encrypt / Decrypt AES-256-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesCipher, HksCryptoHalAesCipher_018, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_CIPHER_018_PARAMS); } -} // namespace AesCipher +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp index d1828a55..11d8f0cc 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_decrypt.cpp @@ -13,320 +13,426 @@ * limitations under the License. */ +#include +#include + #include -#include -#include "hks_config.h" #include "hks_crypto_hal.h" #include "hks_crypto_hal_common.h" #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalAesDecrypt : public HksCryptoHalCommon, public testing::Test {}; - -/** - * @tc.number : HksCryptoHalAesDecrypt_001 - * @tc.name : HksCryptoHalAesDecrypt_001 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CBC-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_001, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + + HksErrorCode decryptResult; +}; +struct TestCaseParamsForGcm { + std::string keyData; + std::string hexData; + std::string tagDec; + + HksErrorCode decryptResult; +}; + +uint8_t IV[16] = {0}; +HksCipherParam tagIv = { .iv = { .size = 16, .data = IV } }; + +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_001_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = &tagIv, - }; + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "2665c033ca1d760d7fcfffce8eb09356a6a6e508584af3faf82fcce81b758934", - const char *hexData = "2665c033ca1d760d7fcfffce8eb09356a6a6e508584af3faf82fcce81b758934"; - uint32_t dataLen = strlen(hexData) / 2; + .decryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_002_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "6b6579306b6579306b6579306b657930", + .hexData = "a043f74ce2620fc939811e9a949e9f0576c60fb964670ed6e626260f7e6d972aca0d0aeff876a8f03fd8ed8b91ff3f9a", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_003_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "2665c033ca1d760d7fcfffce8eb09356a6a6e508584af3faf82fcce81b758934", - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} + .decryptResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalAesDecrypt_002 - * @tc.name : HksCryptoHalAesDecrypt_002 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CBC-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_002, Function | SmallTest | Level1) -{ - int32_t ret; +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_004_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "2665c033ca1d760d7fcfffce8eb09356", - const char *keyData = "6b6579306b6579306b6579306b657930"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_005_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, + .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = - "a043f74ce2620fc939811e9a949e9f0576c60fb964670ed6e626260f7e6d972aca0d0aeff876a8f03fd8ed8b91ff3f9a"; - uint32_t dataLen = strlen(hexData) / 2; + .algParam = nullptr, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "2665c033ca1d760d7fcfffce8eb0935670f5531be24753f04e3200829ea2fd60", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; +const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_006_PARAMS = { + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "fd692103d931c663a0371bd250dd883aed48379774bfba64327cc4a3ea19afae", + .tagDec = "43a345ff5f3af4bb383f999393949acc", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_007_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "6b5d0d7ac2df878c338f085edf3431116b5d0d7ac2df878c338f085edf343111", - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} + .decryptResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalAesDecrypt_003 - * @tc.name : HksCryptoHalAesDecrypt_003 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CTR-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_003, Function | SmallTest | Level1) -{ - int32_t ret; +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_008_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "6b6579306b6579306b6579306b6579306b6579306b657930", + .hexData = "7897f888bda5244c049da27f1533dc80accf7a0c8a9169fa64779d1f34be146dcb0f793048dee9efaa032c7901b07b64", - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_009_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CTR, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = &tagIv, - }; - - const char *hexData = "2665c033ca1d760d7fcfffce8eb09356a6a6e508584af3faf82fcce81b758934"; - uint32_t dataLen = strlen(hexData) / 2; + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "6b5d0d7ac2df878c338f085edf3431116b5d0d7ac2df878c338f085edf343111", - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; + .decryptResult = HKS_SUCCESS, +}; - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_010_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "6b5d0d7ac2df878c338f085edf343111", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + .decryptResult = HKS_SUCCESS, +}; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_011_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "6b5d0d7ac2df878c338f085edf343111cf0afb8fc67acf62db781f324ecc361c", +#if defined(_USE_OPENSSL_) + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; -/** - * @tc.number : HksCryptoHalAesDecrypt_004 - * @tc.name : HksCryptoHalAesDecrypt_004 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-ECB-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_004, Function | SmallTest | Level1) -{ - int32_t ret; +const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_012_PARAMS = { + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "06c34934467ad390f5f54410ac20c875feda920d514c3e43819ce16e1e2e3335", + .tagDec = "b3ad99cd7951405f1eeefb4e54783f17", - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_013_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, + .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "f905f3936288181cb1d3931ab26c0314056d1521dc8549013a9b829bebedc71b", - const char *hexData = "2665c033ca1d760d7fcfffce8eb09356"; - uint32_t dataLen = strlen(hexData) / 2; + .decryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_014_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930", + .hexData = "acec21f1488248cdcf6f24a15124b1a68e401efd146cd944fabd84081b76dacf89989a52f8fc1e31dacb820ec8102365", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_015_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "f905f3936288181cb1d3931ab26c0314056d1521dc8549013a9b829bebedc71b", - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} + .decryptResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalAesDecrypt_005 - * @tc.name : HksCryptoHalAesDecrypt_005 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-ECB-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_005, Function | SmallTest | Level1) -{ - int32_t ret; +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_016_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "f905f3936288181cb1d3931ab26c0314", - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_DECRYPT_017_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "2665c033ca1d760d7fcfffce8eb0935670f5531be24753f04e3200829ea2fd60"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); + }, + .keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930", + .hexData = "776a9f622d0978f89fff5c61ae5d4693776a9f622d0978f89fff5c61ae5d469379ea9dc7d7419ec0ea457aa041e1007a", #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} +}; + +const TestCaseParamsForGcm HKS_CRYPTO_HAL_AES_DECRYPT_018_PARAMS = { + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "da047651955c64daa5cac9b0082f1567235e682041061fef12f896ba83bb1fde", + .tagDec = "35a956a070d5ed7472a9b66165bcada7", + + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalAesDecrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS7) { + outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; + } + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + EXPECT_EQ( + HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &message, &cipherText), testCaseParams.decryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + } + + void GcmRunTestCase(const TestCaseParamsForGcm &testCaseParamsForGcm) + { + uint32_t keyLen = testCaseParamsForGcm.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.keyData[2 * ii]); + } + uint32_t inLen = testCaseParamsForGcm.hexData.length() / 2; + uint32_t outLen = inLen; + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.hexData[2 * ii]); + } + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + uint32_t tagDecSize = testCaseParamsForGcm.tagDec.length() / 2; + HksBlob tagDecBlob = { .size = tagDecSize, .data = (uint8_t *)HksMalloc(tagDecSize) }; + for (uint32_t ii = 0; ii < tagDecSize; ii++) { + tagDecBlob.data[ii] = ReadHex((const uint8_t *)&testCaseParamsForGcm.tagDec[2 * ii]); + } + HksAeadParam aeadParam = { + .nonce = { .size = 16, .data = IV }, + .aad = { .size = 0, .data = nullptr }, + .tagDec = tagDecBlob, + .payloadLen = 0, + }; + HksUsageSpec usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParam, + }; + EXPECT_EQ(HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText), testCaseParamsForGcm.decryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + HksFree(tagDecBlob.data); + } +}; /** - * @tc.number : HksCryptoHalAesDecrypt_006 - * @tc.name : HksCryptoHalAesDecrypt_006 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-GCM-NOPADDING key. + * @tc.number : HksCryptoHalAesDecrypt_001 + * @tc.name : HksCryptoHalAesDecrypt_001 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CBC-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_006, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_001, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - const char *tagData = "43a345ff5f3af4bb383f999393949acc"; - uint32_t tagLen = strlen(keyData) / 2; - HksBlob tagDecrypt = { .size = tagLen, .data = (uint8_t *)HksMalloc(tagLen) }; - for (uint32_t ii = 0; ii < tagLen; ii++) { - tagDecrypt.data[ii] = ReadHex((const uint8_t *)&tagData[2 * ii]); - } - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagDec = tagDecrypt; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_GCM, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &aeadParam, - }; + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_001_PARAMS); +} - const char *hexData = "fd692103d931c663a0371bd250dd883aed48379774bfba64327cc4a3ea19afae"; - uint32_t dataLen = strlen(hexData) / 2; +/** + * @tc.number : HksCryptoHalAesDecrypt_002 + * @tc.name : HksCryptoHalAesDecrypt_002 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_002_PARAMS); +} - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; +/** + * @tc.number : HksCryptoHalAesDecrypt_003 + * @tc.name : HksCryptoHalAesDecrypt_003 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_003_PARAMS); +} - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalAesDecrypt_004 + * @tc.name : HksCryptoHalAesDecrypt_004 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_004_PARAMS); +} - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; +/** + * @tc.number : HksCryptoHalAesDecrypt_005 + * @tc.name : HksCryptoHalAesDecrypt_005 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_005_PARAMS); +} - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(tagDecrypt.data); +/** + * @tc.number : HksCryptoHalAesDecrypt_006 + * @tc.name : HksCryptoHalAesDecrypt_006 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-128-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_006, Function | SmallTest | Level0) +{ + GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_006_PARAMS); } /** @@ -334,47 +440,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_006, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_007 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CBC-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_007, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_007, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "6b5d0d7ac2df878c338f085edf3431116b5d0d7ac2df878c338f085edf343111"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_007_PARAMS); } /** @@ -382,48 +450,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_007, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_008 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CBC-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_008, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_008, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "6b6579306b6579306b6579306b6579306b6579306b657930"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, - .padding = HKS_PADDING_PKCS7, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = - "7897f888bda5244c049da27f1533dc80accf7a0c8a9169fa64779d1f34be146dcb0f793048dee9efaa032c7901b07b64"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_008_PARAMS); } /** @@ -431,47 +460,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_008, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_009 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-CTR-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_009, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_009, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CTR, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "6b5d0d7ac2df878c338f085edf3431116b5d0d7ac2df878c338f085edf343111"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_009_PARAMS); } /** @@ -479,44 +470,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_009, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_010 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-ECB-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_010, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_010, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "6b5d0d7ac2df878c338f085edf343111"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_010_PARAMS); } /** @@ -524,52 +480,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_010, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_011 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-ECB-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_011, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_011, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_PKCS7, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "6b5d0d7ac2df878c338f085edf343111cf0afb8fc67acf62db781f324ecc361c"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -#endif + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_011_PARAMS); } /** @@ -577,60 +490,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_011, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_012 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-192-GCM-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_012, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_012, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - const char *tagData = "b3ad99cd7951405f1eeefb4e54783f17"; - uint32_t tagLen = strlen(tagData) / 2; - HksBlob tagDecrypt = { .size = tagLen, .data = (uint8_t *)HksMalloc(tagLen) }; - for (uint32_t ii = 0; ii < tagLen; ii++) { - tagDecrypt.data[ii] = ReadHex((const uint8_t *)&tagData[2 * ii]); - } - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagDec = tagDecrypt; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_GCM, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &aeadParam, - }; - - const char *hexData = "06c34934467ad390f5f54410ac20c875feda920d514c3e43819ce16e1e2e3335"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(tagDecrypt.data); + GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_012_PARAMS); } /** @@ -638,47 +500,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_012, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_013 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CBC-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_013, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_013, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "f905f3936288181cb1d3931ab26c0314056d1521dc8549013a9b829bebedc71b"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_013_PARAMS); } /** @@ -686,48 +510,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_013, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_014 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CBC-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_014, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_014, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, - .padding = HKS_PADDING_PKCS7, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = - "acec21f1488248cdcf6f24a15124b1a68e401efd146cd944fabd84081b76dacf89989a52f8fc1e31dacb820ec8102365"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_014_PARAMS); } /** @@ -735,47 +520,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_014, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_015 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-CTR-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_015, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_015, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CTR, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "f905f3936288181cb1d3931ab26c0314056d1521dc8549013a9b829bebedc71b"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_015_PARAMS); } /** @@ -783,44 +530,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_015, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_016 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-ECB-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_016, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_016, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "f905f3936288181cb1d3931ab26c0314"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_016_PARAMS); } /** @@ -828,53 +540,9 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_016, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_017 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-ECB-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_017, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_017, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "6b6579306b6579306b6579306b6579306b6579306b6579306b6579306b657930"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_PKCS7, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = - "776a9f622d0978f89fff5c61ae5d4693776a9f622d0978f89fff5c61ae5d469379ea9dc7d7419ec0ea457aa041e1007a"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -#endif + RunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_017_PARAMS); } /** @@ -882,59 +550,11 @@ HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_017, Function | SmallTes * @tc.name : HksCryptoHalAesDecrypt_018 * @tc.desc : Using HksCryptoHalDecrypt Decrypt AES-256-GCM-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_018, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesDecrypt, HksCryptoHalAesDecrypt_018, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - const char *tagData = "35a956a070d5ed7472a9b66165bcada7"; - uint32_t tagLen = strlen(tagData) / 2; - HksBlob tagDecrypt = { .size = tagLen, .data = (uint8_t *)HksMalloc(tagLen) }; - for (uint32_t ii = 0; ii < tagLen; ii++) { - tagDecrypt.data[ii] = ReadHex((const uint8_t *)&tagData[2 * ii]); - } - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagDec = tagDecrypt; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_GCM, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &aeadParam, - }; - - const char *hexData = "da047651955c64daa5cac9b0082f1567235e682041061fef12f896ba83bb1fde"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(tagDecrypt.data); + GcmRunTestCase(HKS_CRYPTO_HAL_AES_DECRYPT_018_PARAMS); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp index d69d919f..a3519d2c 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_encrypt.cpp @@ -22,316 +22,398 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalAesEncrypt : public HksCryptoHalCommon, public testing::Test {}; - -/** - * @tc.number : HksCryptoHalAesEncrypt_001 - * @tc.name : HksCryptoHalAesEncrypt_001 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CBC-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_001, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + + HksErrorCode encryptResult; +}; + +uint8_t IV[16] = {0}; +HksCipherParam tagIv = { .iv = { .size = 16, .data = IV } }; +HksAeadParam aeadParam = { + .nonce = { .size = 16, .data = IV }, + .aad = { .size = 0, .data = nullptr }, + .tagLenEnc = 16, + .payloadLen = 0, +}; + +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_001_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalAesEncrypt_002 - * @tc.name : HksCryptoHalAesEncrypt_002 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CBC-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_002, Function | SmallTest | Level1) -{ - int32_t ret; + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + .encryptResult = HKS_SUCCESS, +}; - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_002_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = &tagIv, - }; + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .encryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_003_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .encryptResult = HKS_SUCCESS, +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_004_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff", - HksBlob tagAead = { .size = 0, .data = nullptr }; + .encryptResult = HKS_SUCCESS, +}; - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_005_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff", +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; -/** - * @tc.number : HksCryptoHalAesEncrypt_003 - * @tc.name : HksCryptoHalAesEncrypt_003 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CTR-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_003, Function | SmallTest | Level1) -{ - int32_t ret; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_006_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParam, + }, + .keyData = "933c213c1f8c844ffcc03f5f7e146a88", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + .encryptResult = HKS_SUCCESS, +}; - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_007_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, - .mode = HKS_MODE_CTR, + .mode = HKS_MODE_CBC, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + .encryptResult = HKS_SUCCESS, +}; - HksBlob tagAead = { .size = 0, .data = nullptr }; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_008_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} + .encryptResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalAesEncrypt_004 - * @tc.name : HksCryptoHalAesEncrypt_004 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-ECB-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_004, Function | SmallTest | Level1) -{ - int32_t ret; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_009_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + .encryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_010_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .encryptResult = HKS_SUCCESS, +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_011_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff", +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksBlob tagAead = { .size = 0, .data = nullptr }; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_012_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_GCM, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &aeadParam, + }, + .keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} + .encryptResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalAesEncrypt_005 - * @tc.name : HksCryptoHalAesEncrypt_005 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-ECB-PKCS7PADDING key. - */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_005, Function | SmallTest | Level1) -{ - int32_t ret; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_013_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CBC, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + .encryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_014_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, + .mode = HKS_MODE_CBC, .padding = HKS_PADDING_PKCS7, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .encryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_015_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_CTR, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = &tagIv, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .encryptResult = HKS_SUCCESS, +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_016_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff", - HksBlob tagAead = { .size = 0, .data = nullptr }; + .encryptResult = HKS_SUCCESS, +}; - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_017_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_AES, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS7, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalAesEncrypt_006 - * @tc.name : HksCryptoHalAesEncrypt_006 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-GCM-NOPADDING key. - */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_006, Function | SmallTest | Level1) -{ - int32_t ret; +}; - const char *keyData = "933c213c1f8c844ffcc03f5f7e146a88"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagLenEnc = 16; - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_ENCRYPT_018_PARAMS = { + .usageSpec = { .algType = HKS_ALG_AES, .mode = HKS_MODE_GCM, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = &aeadParam, - }; + }, + .keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + + .encryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalAesEncrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS7) { + outLen = (inLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; + } + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + HksFree(tagAead.data); + } +}; - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; +/** + * @tc.number : HksCryptoHalAesEncrypt_001 + * @tc.name : HksCryptoHalAesEncrypt_001 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CBC-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_001_PARAMS); +} - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; +/** + * @tc.number : HksCryptoHalAesEncrypt_002 + * @tc.name : HksCryptoHalAesEncrypt_002 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CBC-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_002_PARAMS); +} - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalAesEncrypt_003 + * @tc.name : HksCryptoHalAesEncrypt_003 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-CTR-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_003_PARAMS); +} - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +/** + * @tc.number : HksCryptoHalAesEncrypt_004 + * @tc.name : HksCryptoHalAesEncrypt_004 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-ECB-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_004_PARAMS); +} - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; +/** + * @tc.number : HksCryptoHalAesEncrypt_005 + * @tc.name : HksCryptoHalAesEncrypt_005 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-ECB-PKCS7PADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_005_PARAMS); +} - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(tagAead.data); +/** + * @tc.number : HksCryptoHalAesEncrypt_006 + * @tc.name : HksCryptoHalAesEncrypt_006 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-128-GCM-NOPADDING key. + */ +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_006, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_006_PARAMS); } /** @@ -339,49 +421,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_006, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_007 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-CBC-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_007, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_007, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_007_PARAMS); } /** @@ -389,49 +431,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_007, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_008 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-CBC-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_008, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_008, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, - .padding = HKS_PADDING_PKCS7, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_008_PARAMS); } /** @@ -439,49 +441,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_008, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_009 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-CTR-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_009, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_009, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CTR, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_009_PARAMS); } /** @@ -489,46 +451,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_009, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_010 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-ECB-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_010, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_010, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_010_PARAMS); } /** @@ -536,54 +461,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_010, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_011 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-ECB-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_011, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_011, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_PKCS7, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -#endif + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_011_PARAMS); } /** @@ -591,56 +471,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_011, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_012 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-192-GCM-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_012, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_012, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "7be3cb2c4c900fb318e9c89f828baf9b91783f47c6e8d088"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagLenEnc = 16; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_GCM, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &aeadParam, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(tagAead.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_012_PARAMS); } /** @@ -648,49 +481,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_012, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_013 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-CBC-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_013, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_013, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_013_PARAMS); } /** @@ -698,49 +491,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_013, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_014 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-CBC-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_014, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_014, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CBC, - .padding = HKS_PADDING_PKCS7, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_014_PARAMS); } /** @@ -748,49 +501,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_014, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_015 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-CTR-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_015, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_015, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_CTR, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &tagIv, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_015_PARAMS); } /** @@ -798,46 +511,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_015, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_016 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-ECB-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_016, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_016, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_016_PARAMS); } /** @@ -845,54 +521,9 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_016, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_017 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-ECB-PKCS7PADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_017, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_017, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_PKCS7, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = (dataLen + HKS_PADDING_SUPPLENMENT) / HKS_PADDING_SUPPLENMENT * HKS_PADDING_SUPPLENMENT; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -#endif + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_017_PARAMS); } /** @@ -900,55 +531,11 @@ HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_017, Function | SmallTes * @tc.name : HksCryptoHalAesEncrypt_018 * @tc.desc : Using HksCryptoHalEncrypt Encrypt AES-256-GCM-NOPADDING key. */ -HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_018, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesEncrypt, HksCryptoHalAesEncrypt_018, Function | SmallTest | Level0) { - int32_t ret; - - const char *keyData = "57095bd2ba60c34eaafaa77d694eb809af366810fba500ea660a5048b14b212f"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - uint8_t iv[16] = {0}; - struct HksCipherParam tagIv; - tagIv.iv = { .size = 16, .data = iv }; - struct HksAeadParam aeadParam; - aeadParam.nonce = tagIv.iv; - aeadParam.aad = { .size = 0, .data = nullptr }; - aeadParam.payloadLen = 0; - aeadParam.tagLenEnc = 16; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_AES, - .mode = HKS_MODE_GCM, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = &aeadParam, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(tagAead.data); + RunTestCase(HKS_CRYPTO_HAL_AES_ENCRYPT_018_PARAMS); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp index e6205414..e688ed03 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_aes_key.cpp @@ -22,35 +22,79 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalAesKey : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; -/** - * @tc.number : HksCryptoHalAesKey_001 - * @tc.name : HksCryptoHalAesKey_001 - * @tc.desc : Using HksCryptoHalGenerateKey Generate AES-128bit key. - */ -HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_001, Function | SmallTest | Level1) -{ - int32_t ret; + HksErrorCode generateKeyResult; +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_001_PARAMS = { + .spec = { .algType = HKS_ALG_AES, .keyLen = HKS_AES_KEY_SIZE_128, .algParam = nullptr, - }; + }, +#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksBlob key = { .size = 0, .data = nullptr }; +const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_002_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_192, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - ret = HksCryptoHalGenerateKey(&spec, &key); +const TestCaseParams HKS_CRYPTO_HAL_AES_KEY_003_PARAMS = { + .spec = { + .algType = HKS_ALG_AES, + .keyLen = HKS_AES_KEY_SIZE_256, + .algParam = nullptr, + }, #if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); + .generateKeyResult = HKS_SUCCESS, #else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, #endif +}; +} // namespace + +class HksCryptoHalAesKey : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + ASSERT_NE((uint32_t)0, key.size); + ASSERT_NE(nullptr, key.data); + HksFree(key.data); + } + } +}; + +/** + * @tc.number : HksCryptoHalAesKey_001 + * @tc.name : HksCryptoHalAesKey_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate AES-128bit key. + */ +HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_AES_KEY_001_PARAMS); } /** @@ -58,27 +102,9 @@ HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_001, Function | SmallTest | Leve * @tc.name : HksCryptoHalAesKey_002 * @tc.desc : Using HksCryptoHalGenerateKey Generate AES-192bit key. */ -HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_002, Function | SmallTest | Level0) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_AES, - .keyLen = HKS_AES_KEY_SIZE_192, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_AES_KEY_002_PARAMS); } /** @@ -86,26 +112,11 @@ HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_002, Function | SmallTest | Leve * @tc.name : HksCryptoHalAesKey_003 * @tc.desc : Using HksCryptoHalGenerateKey Generate AES-256bit key. */ -HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalAesKey, HksCryptoHalAesKey_003, Function | SmallTest | Level0) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_AES, - .keyLen = HKS_AES_KEY_SIZE_256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_AES_C) && defined(HKS_SUPPORT_AES_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_AES_KEY_003_PARAMS); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp index f688e182..461086ad 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_mbedtls.cpp @@ -22,7 +22,10 @@ #include "hks_mem.h" using namespace testing::ext; -namespace { +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { class HksCryptoHalApiMbedtls : public HksCryptoHalCommon, public testing::Test {}; /** @@ -30,7 +33,7 @@ class HksCryptoHalApiMbedtls : public HksCryptoHalCommon, public testing::Test { * @tc.name : HksCryptoHalApiMbedtls_001 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- key is NULL. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_001, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_001, Function | SmallTest | Level0) { int32_t ret; @@ -49,7 +52,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_001, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_002 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_002, Function | SmallTest | Level0) { int32_t ret; @@ -70,7 +73,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_002, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_003 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is AES keyLen is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_003, Function | SmallTest | Level0) { int32_t ret; @@ -91,7 +94,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_003, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_004 * @tc.desc : Using HksCryptoHalEncrypt -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTest | Level0) { int32_t ret; @@ -126,7 +129,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_004, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_005 * @tc.desc : Using HksCryptoHalDecrypt -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTest | Level0) { int32_t ret; @@ -160,7 +163,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_005, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_006 * @tc.desc : Using HksCryptoHalEncrypt -- AES encrypt parameter is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTest | Level0) { int32_t ret; @@ -184,7 +187,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_006, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_007 * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt parameter is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTest | Level0) { int32_t ret; @@ -207,7 +210,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_007, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_008 * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt padding is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTest | Level0) { int32_t ret; @@ -230,7 +233,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_008, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_009 * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt CBC mode nopadding with large iv. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTest | Level0) { int32_t ret; @@ -252,7 +255,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_009, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_010 * @tc.desc : Using HksCryptoHalDecrypt -- RSA decrypt key is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTest | Level0) { int32_t ret; @@ -297,7 +300,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_010, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_011 * @tc.desc : Using HksMbedtlsGetRsaPubKey -- RSA in/out key is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTest | Level0) { int32_t ret; @@ -331,7 +334,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_011, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_012 * @tc.desc : Using HksMbedtlsEccGenerateKey -- key size is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTest | Level0) { int32_t ret; @@ -351,7 +354,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_012, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_013 * @tc.desc : Using HksMbedtlsGetEccPubKey -- Ecc in/out key is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTest | Level0) { int32_t ret; @@ -395,7 +398,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_013, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_014 * @tc.desc : Using HksMbedtlsDhGenerateKey -- key size is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTest | Level0) { int32_t ret; @@ -415,7 +418,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_014, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_015 * @tc.desc : Using HksMbedtlsGetDhPubKey -- Ecc in/out key is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTest | Level0) { int32_t ret; @@ -448,7 +451,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_015, Function | SmallTes * @tc.name : HksCryptoHalApiMbedtls_016 * @tc.desc : Using HksMbedtlsDhAgreeKey -- Ecc in/out key is invalid. */ -HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTest | Level0) { int32_t ret; @@ -477,4 +480,7 @@ HWTEST_F(HksCryptoHalApiMbedtls, HksCryptoHalApiMbedtls_016, Function | SmallTes HKS_FREE_BLOB(key); } #endif -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp index 43a67804..4a10d1c3 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_api_openssl.cpp @@ -22,7 +22,10 @@ #include "hks_mem.h" using namespace testing::ext; -namespace { +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { class HksCryptoHalApiOpenssl : public HksCryptoHalCommon, public testing::Test {}; /** @@ -30,7 +33,7 @@ class HksCryptoHalApiOpenssl : public HksCryptoHalCommon, public testing::Test { * @tc.name : HksCryptoHalApiOpenssl_001 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- key is NULL. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTest | Level0) { int32_t ret; @@ -48,7 +51,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_001, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_002 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- algType is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTest | Level0) { int32_t ret; @@ -68,7 +71,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_002, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_003 * @tc.desc : Using HksCryptoHalGenerateKey Generate key -- keyLen is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTest | Level0) { int32_t ret; @@ -110,7 +113,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_003, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_004 * @tc.desc : Using HksCryptoHalEncrypt -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTest | Level0) { int32_t ret; @@ -145,7 +148,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_004, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_005 * @tc.desc : Using HksCryptoHalDecrypt -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTest | Level0) { int32_t ret; @@ -179,7 +182,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_005, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_006 * @tc.desc : Using HksCryptoHalEncrypt -- AES encrypt parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTest | Level0) { int32_t ret; @@ -215,7 +218,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_006, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_007 * @tc.desc : Using HksCryptoHalDecrypt -- AES decrypt parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTest | Level0) { int32_t ret; @@ -243,7 +246,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_007, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_008 * @tc.desc : Using HksCryptoHalDecrypt -- decrypt padding is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTest | Level0) { int32_t ret; @@ -270,7 +273,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_008, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_009 * @tc.desc : Using HksCryptoHalSign -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTest | Level0) { HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec spec = { .algType = 0xffff }; @@ -297,7 +300,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_009, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_010 * @tc.desc : Using HksCryptoHalVerify -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTest | Level0) { HksBlob key = { .size = 0, .data = nullptr }; HksUsageSpec spec = { .algType = 0xffff }; @@ -324,7 +327,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_010, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_011 * @tc.desc : RSA Using HksCryptoHalSign -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTest | Level0) { HksKeySpec spec = { .algType = HKS_ALG_RSA, @@ -352,7 +355,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_011, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_012 * @tc.desc : RSA Using HksCryptoHalVerify -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTest | Level0) { uint8_t buff[HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512)] = {0}; HksBlob key = { .size = sizeof(buff), .data = buff }; @@ -371,7 +374,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_012, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_013 * @tc.desc : DSA Using HksCryptoHalSign -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTest | Level0) { HksKeySpec spec = { .algType = HKS_ALG_DSA, @@ -396,7 +399,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_013, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_014 * @tc.desc : DSA Using HksCryptoHalVerify -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTest | Level0) { uint8_t buff[HKS_KEY_BYTES(256)] = {0}; HksBlob key = { .size = sizeof(buff), .data = buff }; @@ -412,7 +415,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_014, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_015 * @tc.desc : ECDSA Using HksCryptoHalSign -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTest | Level0) { uint8_t buff[HKS_KEY_BYTES(HKS_ECC_KEY_SIZE_256)] = {0}; HksBlob key = { .size = sizeof(buff), .data = buff }; @@ -428,7 +431,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_015, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_016 * @tc.desc : ECDSA Using HksCryptoHalVerify -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTest | Level0) { HksKeySpec spec = { .algType = HKS_ALG_ECC, @@ -453,7 +456,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_016, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_017 * @tc.desc : Using HksCryptoHalAgreeKey -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTest | Level0) { HksBlob key = { .size = 0, .data = nullptr }; HksBlob pubKey = { .size = 0, .data = nullptr }; @@ -480,7 +483,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_017, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_018 * @tc.desc : ECDH Using HksCryptoHalAgreeKey -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTest | Level0) { HksKeySpec keySpec = { .algType = HKS_ALG_ECC, @@ -509,7 +512,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_018, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_019 * @tc.desc : DH Using HksCryptoHalAgreeKey -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTest | Level0) { HksKeySpec keySpec = { .algType = HKS_ALG_DH, @@ -539,7 +542,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_019, Function | SmallTes * @tc.name : HksCryptoHalApiOpenssl_020 * @tc.desc : Using HksCryptoHalAgreeKey -- parameter is invalid. */ -HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTest | Level0) { HksBlob key = { .size = 0, .data = nullptr }; HksBlob message = { .size = 0, .data = nullptr }; @@ -559,4 +562,7 @@ HWTEST_F(HksCryptoHalApiOpenssl, HksCryptoHalApiOpenssl_020, Function | SmallTes EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA512, &message, &signature), HKS_ERROR_INVALID_ARGUMENT); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp index 3920f7ba..09fe2439 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh.cpp @@ -13,7 +13,6 @@ * limitations under the License. */ -#ifdef HKS_SUPPORT_DH_C #include #include @@ -22,27 +21,54 @@ #include "hks_crypto_hal_common.h" #include "hks_config.h" +#ifdef HKS_SUPPORT_DH_C + using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalDh : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; + + HksErrorCode generateKeyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_001_PARAMS = { + .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_2048, }, + .generateKeyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_002_PARAMS = { + .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_3072, }, + .generateKeyResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_003_PARAMS = { + .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096, }, + .generateKeyResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalDh : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { 0, NULL }; + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + HKS_FREE_BLOB(key); + } +}; /** * @tc.number : HksCryptoHalDh_001 * @tc.name : HksCryptoHalDh_001 * @tc.desc : Generate Dh-2048 key pair */ -HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_001, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_001, Function | SmallTest | Level0) { - int32_t ret; - - HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_2048 }; - - HksBlob key = { 0, NULL }; - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - - HKS_FREE_BLOB(key); + RunTestCase(HKS_CRYPTO_HAL_DH_001_PARAMS); } /** @@ -50,18 +76,9 @@ HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_001, Function | SmallTest | Level1) * @tc.name : HksCryptoHalDh_002 * @tc.desc : Generate Dh-3072 key pair */ -HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_002, Function | SmallTest | Level0) { - int32_t ret; - - HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_3072 }; - - HksBlob key = { 0, NULL }; - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - - HKS_FREE_BLOB(key); + RunTestCase(HKS_CRYPTO_HAL_DH_002_PARAMS); } /** @@ -69,18 +86,12 @@ HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_002, Function | SmallTest | Level1) * @tc.name : HksCryptoHalDh_003 * @tc.desc : Generate Dh-4096 key pair */ -HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDh, HksCryptoHalDh_003, Function | SmallTest | Level0) { - int32_t ret; - - HksKeySpec spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_4096 }; - - HksBlob key = { 0, NULL }; - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - - HKS_FREE_BLOB(key); + RunTestCase(HKS_CRYPTO_HAL_DH_003_PARAMS); } -} // namespace +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS #endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp index 3253255e..b33d364e 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dh_agree.cpp @@ -13,7 +13,6 @@ * limitations under the License. */ -#ifdef HKS_SUPPORT_DH_C #include #include @@ -22,50 +21,94 @@ #include "hks_crypto_hal_common.h" #include "hks_mem.h" +#ifdef HKS_SUPPORT_DH_C + using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalDhAgree : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; -/** - * @tc.number : HksCryptoHalDhAgree_001 - * @tc.name : HksCryptoHalDhAgree_001 - * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-2048 key. - */ -HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_001, Function | SmallTest | Level1) -{ - HksKeySpec spec = { + HksErrorCode generateKeyResult; + HksErrorCode agreeResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_001_PARAMS = { + .spec = { .algType = HKS_ALG_DH, .keyLen = HKS_DH_KEY_SIZE_2048, .algParam = nullptr, - }; + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; - HksBlob alise = { .size = 0, .data = nullptr }; - HksBlob bob = { .size = 0, .data = nullptr }; +const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_002_PARAMS = { + .spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_3072, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); +const TestCaseParams HKS_CRYPTO_HAL_DH_AGREE_003_PARAMS = { + .spec = { + .algType = HKS_ALG_DH, + .keyLen = HKS_DH_KEY_SIZE_4096, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalDhAgree : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &alise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &bob), HKS_SUCCESS); - struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); - struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; + struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &testCaseParams.spec, &agreeKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &testCaseParams.spec, &agreeKeyBob), HKS_SUCCESS); - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - HksFree(alise.data); - HksFree(bob.data); - HksFree(pubKeyAlise.data); - HksFree(pubKeyBob.data); - HksFree(agreeKeyAlise.data); - HksFree(agreeKeyBob.data); + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); + } +}; + +/** + * @tc.number : HksCryptoHalDhAgree_001 + * @tc.name : HksCryptoHalDhAgree_001 + * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-2048 key. + */ +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_001_PARAMS); } /** @@ -73,41 +116,9 @@ HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_001, Function | SmallTest | Le * @tc.name : HksCryptoHalDhAgree_002 * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-3072 key. */ -HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_002, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_DH, - .keyLen = HKS_DH_KEY_SIZE_3072, - .algParam = nullptr, - }; - - HksBlob alise = { .size = 0, .data = nullptr }; - HksBlob bob = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); - - struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - - EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFree(alise.data); - HksFree(bob.data); - HksFree(pubKeyAlise.data); - HksFree(pubKeyBob.data); - HksFree(agreeKeyAlise.data); - HksFree(agreeKeyBob.data); + RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_002_PARAMS); } /** @@ -115,41 +126,12 @@ HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_002, Function | SmallTest | Le * @tc.name : HksCryptoHalDhAgree_003 * @tc.desc : Using HksCryptoHalAgreeKey Agree DH-4096 key. */ -HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDhAgree, HksCryptoHalDhAgree_003, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_DH, - .keyLen = HKS_DH_KEY_SIZE_4096, - .algParam = nullptr, - }; - - HksBlob alise = { .size = 0, .data = nullptr }; - HksBlob bob = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - struct HksBlob pubKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); - - struct HksBlob agreeKeyAlise = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - struct HksBlob agreeKeyBob = { .size = 4096, .data = (uint8_t *)HksMalloc(4096) }; - - EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFree(alise.data); - HksFree(bob.data); - HksFree(pubKeyAlise.data); - HksFree(pubKeyBob.data); - HksFree(agreeKeyAlise.data); - HksFree(agreeKeyBob.data); + RunTestCase(HKS_CRYPTO_HAL_DH_AGREE_003_PARAMS); } -} // namespace +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS #endif \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp index 3a887002..d6d204a4 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_key.cpp @@ -22,7 +22,10 @@ #include "hks_mem.h" using namespace testing::ext; -namespace { +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { class HksCryptoHalDsaKey : public HksCryptoHalCommon, public testing::Test {}; /** @@ -30,7 +33,7 @@ class HksCryptoHalDsaKey : public HksCryptoHalCommon, public testing::Test {}; * @tc.name : HksCryptoHalDsaKey_001 * @tc.desc : Using HksCryptoHalGenerateKey Generate DSA-256bit key. */ -HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_001, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_001, Function | SmallTest | Level0) { int32_t ret; @@ -64,7 +67,7 @@ HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_001, Function | SmallTest | Leve * @tc.name : HksCryptoHalDsaKey_002 * @tc.desc : Generate key and export public key with DSA. */ -HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Level0) { int32_t ret; @@ -100,4 +103,7 @@ HWTEST_F(HksCryptoHalDsaKey, HksCryptoHalDsaKey_002, Function | SmallTest | Leve HKS_FREE_BLOB(key); HKS_FREE_BLOB(keyOut); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp index 95e71cfc..5976f484 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_dsa_sign.cpp @@ -22,61 +22,104 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalDsaSign : public HksCryptoHalCommon, public testing::Test {}; - -/** - * @tc.number : HksCryptoHalDsaSign_001 - * @tc.name : HksCryptoHalDsaSign_001 - * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA1 key. - */ -HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Level1) -{ - HksKeySpec spec = { - .algType = HKS_ALG_DSA, - .keyLen = 256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_001_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; + +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_002_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; + +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_003_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; + +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_004_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; + +const HksUsageSpec HKS_CRYPTO_HAL_DSA_SIGN_005_SPEC = { + .algType = HKS_ALG_DSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, +}; +} // namespace + +class HksCryptoHalDsaSign : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const HksUsageSpec &hksUsageSpec) + { + HksKeySpec spec = { + .algType = HKS_ALG_DSA, + .keyLen = 256, + .algParam = nullptr, + }; + + HksBlob key = { .size = 0, .data = nullptr }; #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); - return; + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); + return; #endif #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); #endif - HksUsageSpec usageSpec = { - .algType = HKS_ALG_DSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA1, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + EXPECT_EQ(HksCryptoHalSign(&key, &hksUsageSpec, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalVerify(&pubKey, &hksUsageSpec, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + HksFree(key.data); + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + } +}; - HksFree(key.data); - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); +/** + * @tc.number : HksCryptoHalDsaSign_001 + * @tc.name : HksCryptoHalDsaSign_001 + * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA1 key. + */ +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_001_SPEC); } /** @@ -84,53 +127,9 @@ HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_001, Function | SmallTest | Le * @tc.name : HksCryptoHalDsaSign_002 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA224 key. */ -HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_DSA, - .keyLen = 256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); - return; -#endif -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); -#endif - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_DSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA224, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(key.data); - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_002_SPEC); } /** @@ -138,53 +137,9 @@ HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_002, Function | SmallTest | Le * @tc.name : HksCryptoHalDsaSign_003 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA256 key. */ -HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_DSA, - .keyLen = 256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); - return; -#endif -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); -#endif - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_DSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA256, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(key.data); - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_003_SPEC); } /** @@ -192,53 +147,9 @@ HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_003, Function | SmallTest | Le * @tc.name : HksCryptoHalDsaSign_004 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA384 key. */ -HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_DSA, - .keyLen = 256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); - return; -#endif -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); -#endif - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_DSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA384, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(key.data); - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_004_SPEC); } /** @@ -246,52 +157,11 @@ HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_004, Function | SmallTest | Le * @tc.name : HksCryptoHalDsaSign_005 * @tc.desc : Using HksCryptoHalSign Sign DSA-SHA512 key. */ -HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_005, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalDsaSign, HksCryptoHalDsaSign_005, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_DSA, - .keyLen = 256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_ERROR_NOT_SUPPORTED); - return; -#endif -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); -#endif - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_DSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA512, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(key.data); - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); + RunTestCase(HKS_CRYPTO_HAL_DSA_SIGN_005_SPEC); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp index 33db49d1..82fb1b33 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecc_key.cpp @@ -22,35 +22,92 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalEccKey : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; -/** - * @tc.number : HksCryptoHalEccKey_001 - * @tc.name : HksCryptoHalEccKey_001 - * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-224bit key. - */ -HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Level1) -{ - int32_t ret; + HksErrorCode generateKeyResult; +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_001_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_224, .algParam = nullptr, - }; + }, +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksBlob key = { .size = 0, .data = nullptr }; +const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_002_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - ret = HksCryptoHalGenerateKey(&spec, &key); +const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_003_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECC_KEY_004_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, #if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); + .generateKeyResult = HKS_SUCCESS, #else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, #endif +}; +} // namespace + +class HksCryptoHalEccKey : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + ASSERT_NE((uint32_t)0, key.size); + ASSERT_NE(nullptr, key.data); + HksFree(key.data); + } + } +}; + +/** + * @tc.number : HksCryptoHalEccKey_001 + * @tc.name : HksCryptoHalEccKey_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-224bit key. + */ +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_001_PARAMS); } /** @@ -58,27 +115,9 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_001, Function | SmallTest | Leve * @tc.name : HksCryptoHalEccKey_002 * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-256bit key. */ -HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Level0) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_002_PARAMS); } /** @@ -86,27 +125,9 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_002, Function | SmallTest | Leve * @tc.name : HksCryptoHalEccKey_003 * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-384bit key. */ -HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Level0) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_384, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_003_PARAMS); } /** @@ -114,27 +135,9 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_003, Function | SmallTest | Leve * @tc.name : HksCryptoHalEccKey_004 * @tc.desc : Using HksCryptoHalGenerateKey Generate ECC-521bit key. */ -HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Level0) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_521, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_ECC_C) && defined(HKS_SUPPORT_ECC_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_ECC_KEY_004_PARAMS); } /** @@ -142,7 +145,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_004, Function | SmallTest | Leve * @tc.name : HksCryptoHalEccKey_005 * @tc.desc : Generate key and export public key with ECC. */ -HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Level0) { int32_t ret; @@ -166,4 +169,7 @@ HWTEST_F(HksCryptoHalEccKey, HksCryptoHalEccKey_005, Function | SmallTest | Leve HKS_FREE_BLOB(key); HKS_FREE_BLOB(keyOut); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp index 4bb5cfae..91a1045a 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdh_agree.cpp @@ -22,51 +22,124 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalEcdhAgree : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; + HksKeySpec specForAgree; -/** - * @tc.number : HksCryptoHalEcdhAgree_001 - * @tc.name : HksCryptoHalEcdhAgree_001 - * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-224 key. - */ -HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest | Level1) -{ - HksKeySpec spec = { + HksErrorCode generateKeyResult; + HksErrorCode agreeResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_001_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_224, .algParam = nullptr, - }; - - HksBlob alise = { .size = 0, .data = nullptr }; - HksBlob bob = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); - - struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + }, + .specForAgree = { + .algType = HKS_ALG_ECDH, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; - spec.algType = HKS_ALG_ECDH; +const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_002_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .specForAgree = { + .algType = HKS_ALG_ECDH, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); +const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_003_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .specForAgree = { + .algType = HKS_ALG_ECDH, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); +const TestCaseParams HKS_CRYPTO_HAL_ECDH_AGREE_004_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .specForAgree = { + .algType = HKS_ALG_ECDH, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalEcdhAgree : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob alise = { .size = 0, .data = nullptr }; + HksBlob bob = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &bob), testCaseParams.generateKeyResult); + + struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); + + struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; + + EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &testCaseParams.specForAgree, &agreeKeyAlise), + testCaseParams.agreeResult); + EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &testCaseParams.specForAgree, &agreeKeyBob), + testCaseParams.agreeResult); + + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFree(alise.data); + HksFree(bob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); + } +}; - HksFree(alise.data); - HksFree(bob.data); - HksFree(pubKeyAlise.data); - HksFree(pubKeyBob.data); - HksFree(agreeKeyAlise.data); - HksFree(agreeKeyBob.data); +/** + * @tc.number : HksCryptoHalEcdhAgree_001 + * @tc.name : HksCryptoHalEcdhAgree_001 + * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-224 key. + */ +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_001_PARAMS); } /** @@ -74,43 +147,9 @@ HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_001, Function | SmallTest * @tc.name : HksCryptoHalEcdhAgree_002 * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-256 key. */ -HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_256, - .algParam = nullptr, - }; - - HksBlob alise = { .size = 0, .data = nullptr }; - HksBlob bob = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); - - struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - - spec.algType = HKS_ALG_ECDH; - - EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFree(alise.data); - HksFree(bob.data); - HksFree(pubKeyAlise.data); - HksFree(pubKeyBob.data); - HksFree(agreeKeyAlise.data); - HksFree(agreeKeyBob.data); + RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_002_PARAMS); } /** @@ -118,43 +157,9 @@ HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_002, Function | SmallTest * @tc.name : HksCryptoHalEcdhAgree_003 * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-384 key. */ -HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_384, - .algParam = nullptr, - }; - - HksBlob alise = { .size = 0, .data = nullptr }; - HksBlob bob = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); - - struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - - spec.algType = HKS_ALG_ECDH; - - EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFree(alise.data); - HksFree(bob.data); - HksFree(pubKeyAlise.data); - HksFree(pubKeyBob.data); - HksFree(agreeKeyAlise.data); - HksFree(agreeKeyBob.data); + RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_003_PARAMS); } /** @@ -162,42 +167,11 @@ HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_003, Function | SmallTest * @tc.name : HksCryptoHalEcdhAgree_004 * @tc.desc : Using HksCryptoHalAgreeKey Agree ECC-521 key. */ -HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_004, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEcdhAgree, HksCryptoHalEcdhAgree_004, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_521, - .algParam = nullptr, - }; - - HksBlob alise = { .size = 0, .data = nullptr }; - HksBlob bob = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &alise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &bob), HKS_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - struct HksBlob pubKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&alise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalGetPubKey(&bob, &pubKeyBob), HKS_SUCCESS); - - struct HksBlob agreeKeyAlise = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - struct HksBlob agreeKeyBob = { .size = 256, .data = (uint8_t *)HksMalloc(256) }; - - spec.algType = HKS_ALG_ECDH; - - EXPECT_EQ(HksCryptoHalAgreeKey(&alise, &pubKeyBob, &spec, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksCryptoHalAgreeKey(&bob, &pubKeyAlise, &spec, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFree(alise.data); - HksFree(bob.data); - HksFree(pubKeyAlise.data); - HksFree(pubKeyBob.data); - HksFree(agreeKeyAlise.data); - HksFree(agreeKeyBob.data); + RunTestCase(HKS_CRYPTO_HAL_ECDH_AGREE_004_PARAMS); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp index eeddacf8..3f725d5c 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_ecdsa_sign.cpp @@ -22,1063 +22,728 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalEcdsaSign : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; + HksUsageSpec usageSpec; -/** - * @tc.number : HksCryptoHalEcdsaSign_001 - * @tc.name : HksCryptoHalEcdsaSign_001 - * @tc.desc : Using HksCryptoHalSign Sign ECC-224-NONE key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_001, Function | SmallTest | Level1) -{ - HksKeySpec spec = { + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_001_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_224, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + }, - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_002 - * @tc.name : HksCryptoHalEcdsaSign_002 - * @tc.desc : Using HksCryptoHalSign Sign ECC-256-NONE key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_002, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_002_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + }, - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_003 - * @tc.name : HksCryptoHalEcdsaSign_003 - * @tc.desc : Using HksCryptoHalSign Sign ECC-384-NONE key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_003, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_003_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_384, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + }, - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_004 - * @tc.name : HksCryptoHalEcdsaSign_004 - * @tc.desc : Using HksCryptoHalSign Sign ECC-521-NONE key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_004, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_004_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_521, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + }, - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_005 - * @tc.name : HksCryptoHalEcdsaSign_005 - * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA1 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_005, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_005_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_224, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + }, - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_006 - * @tc.name : HksCryptoHalEcdsaSign_006 - * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA1 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_006, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_006_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + }, - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_007 - * @tc.name : HksCryptoHalEcdsaSign_007 - * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA1 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_007, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_007_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_384, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; + }, - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_008 - * @tc.name : HksCryptoHalEcdsaSign_008 - * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA1 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_008, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_008_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_521, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + }, - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalEcdsaSign_009 - * @tc.name : HksCryptoHalEcdsaSign_009 - * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA224 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_009, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_009_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_224, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + }, - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_010 - * @tc.name : HksCryptoHalEcdsaSign_010 - * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA224 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_010, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_010_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + }, - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_011 - * @tc.name : HksCryptoHalEcdsaSign_011 - * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA224 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_011, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_011_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_384, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + }, - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_012 - * @tc.name : HksCryptoHalEcdsaSign_012 - * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA224 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_012, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_012_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_521, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + }, - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_013 - * @tc.name : HksCryptoHalEcdsaSign_013 - * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA256 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_013, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_013_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_224, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA256, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + }, - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_014 - * @tc.name : HksCryptoHalEcdsaSign_014 - * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA256 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_014, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_014_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA256, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + }, - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_015 - * @tc.name : HksCryptoHalEcdsaSign_015 - * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA256 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_015, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_015_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_384, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_016_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_521, + .algParam = nullptr, + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA256, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; + }, - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_016 - * @tc.name : HksCryptoHalEcdsaSign_016 - * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA256 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_016, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_017_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_521, + .keyLen = HKS_ECC_KEY_SIZE_224, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA256, + .digest = HKS_DIGEST_SHA384, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; + }, - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_017 - * @tc.name : HksCryptoHalEcdsaSign_017 - * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA384 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_017, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_018_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_224, + .keyLen = HKS_ECC_KEY_SIZE_256, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA384, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; + }, - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_018 - * @tc.name : HksCryptoHalEcdsaSign_018 - * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA384 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_018, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_019_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_256, + .keyLen = HKS_ECC_KEY_SIZE_384, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA384, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + }, - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} - -/** - * @tc.number : HksCryptoHalEcdsaSign_019 - * @tc.name : HksCryptoHalEcdsaSign_019 - * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA384 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_019, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_020_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_384, + .keyLen = HKS_ECC_KEY_SIZE_521, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_SHA384, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; + }, - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_021_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_224, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_022_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_256, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_023_PARAMS = { + .spec = { + .algType = HKS_ALG_ECC, + .keyLen = HKS_ECC_KEY_SIZE_384, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_ECC, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, + }, - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalEcdsaSign_020 - * @tc.name : HksCryptoHalEcdsaSign_020 - * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA384 key. - */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_020, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_ECDSA_SIGN_024_PARAMS = { + .spec = { .algType = HKS_ALG_ECC, .keyLen = HKS_ECC_KEY_SIZE_521, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_ECC, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA384, + .digest = HKS_DIGEST_SHA512, .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; + }, - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; +class HksCryptoHalEcdsaSign : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); + EXPECT_EQ(HksCryptoHalSign(&key, &testCaseParams.usageSpec, &message, &signature), testCaseParams.signResult); - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); -} + struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; + + EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); + + EXPECT_EQ( + HksCryptoHalVerify(&pubKey, &testCaseParams.usageSpec, &message, &signature), testCaseParams.verifyResult); + + HksFree(message.data); + HksFree(signature.data); + HksFree(pubKey.data); + HksFree(key.data); + } +}; /** - * @tc.number : HksCryptoHalEcdsaSign_021 - * @tc.name : HksCryptoHalEcdsaSign_021 - * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA512 key. + * @tc.number : HksCryptoHalEcdsaSign_001 + * @tc.name : HksCryptoHalEcdsaSign_001 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-NONE key. */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_021, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_001, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_224, - .algParam = nullptr, - }; + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_001_PARAMS); +} - HksBlob key = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalEcdsaSign_002 + * @tc.name : HksCryptoHalEcdsaSign_002 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_002_PARAMS); +} - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalEcdsaSign_003 + * @tc.name : HksCryptoHalEcdsaSign_003 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_003, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_003_PARAMS); +} - HksUsageSpec usageSpec = { - .algType = HKS_ALG_ECC, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA512, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; +/** + * @tc.number : HksCryptoHalEcdsaSign_004 + * @tc.name : HksCryptoHalEcdsaSign_004 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-NONE key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_004, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_004_PARAMS); +} - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; +/** + * @tc.number : HksCryptoHalEcdsaSign_005 + * @tc.name : HksCryptoHalEcdsaSign_005 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_005, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_005_PARAMS); +} - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; +/** + * @tc.number : HksCryptoHalEcdsaSign_006 + * @tc.name : HksCryptoHalEcdsaSign_006 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_006, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_006_PARAMS); +} - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalEcdsaSign_007 + * @tc.name : HksCryptoHalEcdsaSign_007 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_007, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_007_PARAMS); +} - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; +/** + * @tc.number : HksCryptoHalEcdsaSign_008 + * @tc.name : HksCryptoHalEcdsaSign_008 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA1 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_008, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_008_PARAMS); +} - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalEcdsaSign_009 + * @tc.name : HksCryptoHalEcdsaSign_009 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_009, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_009_PARAMS); +} - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalEcdsaSign_010 + * @tc.name : HksCryptoHalEcdsaSign_010 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_010, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_010_PARAMS); +} - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); +/** + * @tc.number : HksCryptoHalEcdsaSign_011 + * @tc.name : HksCryptoHalEcdsaSign_011 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA224 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_011, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_011_PARAMS); } /** - * @tc.number : HksCryptoHalEcdsaSign_022 - * @tc.name : HksCryptoHalEcdsaSign_022 - * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA512 key. + * @tc.number : HksCryptoHalEcdsaSign_012 + * @tc.name : HksCryptoHalEcdsaSign_012 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA224 key. */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_022, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_012, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_256, - .algParam = nullptr, - }; + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_012_PARAMS); +} - HksBlob key = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalEcdsaSign_013 + * @tc.name : HksCryptoHalEcdsaSign_013 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_013, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_013_PARAMS); +} - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalEcdsaSign_014 + * @tc.name : HksCryptoHalEcdsaSign_014 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_014, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_014_PARAMS); +} - HksUsageSpec usageSpec = { - .algType = HKS_ALG_ECC, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA512, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; +/** + * @tc.number : HksCryptoHalEcdsaSign_015 + * @tc.name : HksCryptoHalEcdsaSign_015 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_015, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_015_PARAMS); +} - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; +/** + * @tc.number : HksCryptoHalEcdsaSign_016 + * @tc.name : HksCryptoHalEcdsaSign_016 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA256 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_016, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_016_PARAMS); +} - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; +/** + * @tc.number : HksCryptoHalEcdsaSign_017 + * @tc.name : HksCryptoHalEcdsaSign_017 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_017, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_017_PARAMS); +} - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalEcdsaSign_018 + * @tc.name : HksCryptoHalEcdsaSign_018 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_018, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_018_PARAMS); +} - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; +/** + * @tc.number : HksCryptoHalEcdsaSign_019 + * @tc.name : HksCryptoHalEcdsaSign_019 + * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_019, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_019_PARAMS); +} - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalEcdsaSign_020 + * @tc.name : HksCryptoHalEcdsaSign_020 + * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA384 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_020, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_020_PARAMS); +} - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalEcdsaSign_021 + * @tc.name : HksCryptoHalEcdsaSign_021 + * @tc.desc : Using HksCryptoHalSign Sign ECC-224-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_021, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_021_PARAMS); +} - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); +/** + * @tc.number : HksCryptoHalEcdsaSign_022 + * @tc.name : HksCryptoHalEcdsaSign_022 + * @tc.desc : Using HksCryptoHalSign Sign ECC-256-SHA512 key. + */ +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_022, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_022_PARAMS); } /** @@ -1086,47 +751,9 @@ HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_022, Function | SmallTest * @tc.name : HksCryptoHalEcdsaSign_023 * @tc.desc : Using HksCryptoHalSign Sign ECC-384-SHA512 key. */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_023, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_023, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_384, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_ECC, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA512, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_023_PARAMS); } /** @@ -1134,46 +761,11 @@ HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_023, Function | SmallTest * @tc.name : HksCryptoHalEcdsaSign_024 * @tc.desc : Using HksCryptoHalSign Sign ECC-521-SHA512 key. */ -HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_024, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalEcdsaSign, HksCryptoHalEcdsaSign_024, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_ECC, - .keyLen = HKS_ECC_KEY_SIZE_521, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_ECC, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_SHA512, - .purpose = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY, - }; - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 521, .data = (uint8_t *)HksMalloc(521) }; - - EXPECT_EQ(HksCryptoHalSign(&key, &usageSpec, &message, &signature), HKS_SUCCESS); - - struct HksBlob pubKey = { .size = 218, .data = (uint8_t *)HksMalloc(218) }; - - EXPECT_EQ(HksCryptoHalGetPubKey(&key, &pubKey), HKS_SUCCESS); - - EXPECT_EQ(HksCryptoHalVerify(&pubKey, &usageSpec, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(pubKey.data); - HksFree(key.data); + RunTestCase(HKS_CRYPTO_HAL_ECDSA_SIGN_024_PARAMS); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp index d1b25956..561acd9a 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_hmac.cpp @@ -22,73 +22,123 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalHmacHmac : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; + HksKeyDigest digest; -/** - * @tc.number : HksCryptoHalHmacHmac_001 - * @tc.name : HksCryptoHalHmacHmac_001 - * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA1 key. - */ -HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_001, Function | SmallTest | Level1) -{ - HksKeySpec spec = { + HksErrorCode generateKeyResult; + HksErrorCode hmacResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_001_PARAMS = { + .spec = { .algType = HKS_ALG_HMAC, .keyLen = 256, .algParam = nullptr, - }; + }, + .digest = HKS_DIGEST_SHA1, - HksBlob key = { .size = 0, .data = nullptr }; + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_002_PARAMS = { + .spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }, + .digest = HKS_DIGEST_SHA224, - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_003_PARAMS = { + .spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }, + .digest = HKS_DIGEST_SHA256, - EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA1, &message, &signature), HKS_SUCCESS); + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; - HksFree(message.data); - HksFree(signature.data); - HksFree(key.data); -} +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_004_PARAMS = { + .spec = { + .algType = HKS_ALG_HMAC, + .keyLen = 256, + .algParam = nullptr, + }, + .digest = HKS_DIGEST_SHA384, -/** - * @tc.number : HksCryptoHalHmacHmac_002 - * @tc.name : HksCryptoHalHmacHmac_002 - * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA224 key. - */ -HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_002, Function | SmallTest | Level1) -{ - HksKeySpec spec = { + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_HMAC_HMAC_005_PARAMS = { + .spec = { .algType = HKS_ALG_HMAC, .keyLen = 256, .algParam = nullptr, - }; + }, + .digest = HKS_DIGEST_SHA512, + + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; +} // namespace + +class HksCryptoHalHmacHmac : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; - HksBlob key = { .size = 0, .data = nullptr }; + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); + const char *hexData = "00112233445566778899aabbccddeeff"; + uint32_t dataLen = strlen(hexData) / 2; - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; + for (uint32_t ii = 0; ii < dataLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + } + struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); + EXPECT_EQ(HksCryptoHalHmac(&key, testCaseParams.digest, &message, &signature), testCaseParams.hmacResult); + + HksFree(message.data); + HksFree(signature.data); + HksFree(key.data); } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; +}; - EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA224, &message, &signature), HKS_SUCCESS); +/** + * @tc.number : HksCryptoHalHmacHmac_001 + * @tc.name : HksCryptoHalHmacHmac_001 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA1 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_001, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_001_PARAMS); +} - HksFree(message.data); - HksFree(signature.data); - HksFree(key.data); +/** + * @tc.number : HksCryptoHalHmacHmac_002 + * @tc.name : HksCryptoHalHmacHmac_002 + * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA224 key. + */ +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_002, Function | SmallTest | Level0) +{ + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_002_PARAMS); } /** @@ -96,32 +146,9 @@ HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_002, Function | SmallTest | * @tc.name : HksCryptoHalHmacHmac_003 * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA256 key. */ -HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_003, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_003, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_HMAC, - .keyLen = 256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA256, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(key.data); + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_003_PARAMS); } /** @@ -129,32 +156,9 @@ HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_003, Function | SmallTest | * @tc.name : HksCryptoHalHmacHmac_004 * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA384 key. */ -HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_004, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_004, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_HMAC, - .keyLen = 256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA384, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(key.data); + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_004_PARAMS); } /** @@ -162,31 +166,11 @@ HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_004, Function | SmallTest | * @tc.name : HksCryptoHalHmacHmac_005 * @tc.desc : Using HksCryptoHalHmac HMAC HMAC-256-SHA512 key. */ -HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_005, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalHmacHmac, HksCryptoHalHmacHmac_005, Function | SmallTest | Level0) { - HksKeySpec spec = { - .algType = HKS_ALG_HMAC, - .keyLen = 256, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - EXPECT_EQ(HksCryptoHalGenerateKey(&spec, &key), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - HksBlob message = { .size = dataLen, .data = (uint8_t *)HksMalloc(dataLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - struct HksBlob signature = { .size = 1024, .data = (uint8_t *)HksMalloc(1024) }; - - EXPECT_EQ(HksCryptoHalHmac(&key, HKS_DIGEST_SHA512, &message, &signature), HKS_SUCCESS); - - HksFree(message.data); - HksFree(signature.data); - HksFree(key.data); + RunTestCase(HKS_CRYPTO_HAL_HMAC_HMAC_005_PARAMS); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp index ef7c8ed7..ff5c385b 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_hmac_key.cpp @@ -22,7 +22,10 @@ #include "hks_mem.h" using namespace testing::ext; -namespace { +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { class HksCryptoHalHmacKey : public HksCryptoHalCommon, public testing::Test {}; /** @@ -30,7 +33,7 @@ class HksCryptoHalHmacKey : public HksCryptoHalCommon, public testing::Test {}; * @tc.name : HksCryptoHalHmacKey_001 * @tc.desc : Using HksCryptoHalGenerateKey Generate HMAC-256bit key. */ -HWTEST_F(HksCryptoHalHmacKey, HksCryptoHalHmacKey_001, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalHmacKey, HksCryptoHalHmacKey_001, Function | SmallTest | Level0) { int32_t ret; @@ -52,4 +55,7 @@ HWTEST_F(HksCryptoHalHmacKey, HksCryptoHalHmacKey_001, Function | SmallTest | Le ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); #endif } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp index d44c6a3e..1333060d 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_cipher.cpp @@ -22,1822 +22,1148 @@ #include "hks_mem.h" using namespace testing::ext; -namespace RsaCipher { +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -const char RSA_2048_NOPADDING_KEY[] = - "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000"; -const char RSA_3072_NOPADDING_KEY[] = - "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; -const char RSA_4096_NOPADDING_KEY[] = - "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000"; -} // namespace -class HksCryptoHalRsaCipher : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; + HksUsageSpec usageSpec; + std::string hexData; -/** - * @tc.number : HksCryptoHalRsaCipher_001 - * @tc.name : HksCryptoHalRsaCipher_001 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_001, Function | SmallTest | Level1) -{ - HksKeySpec spec = { + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_001_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_512, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" - "0000000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" + "0000000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +}; -/** - * @tc.number : HksCryptoHalRsaCipher_002 - * @tc.name : HksCryptoHalRsaCipher_002 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_002, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_002_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_768, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - uint32_t inscriptionLen = dataLen; + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +}; -/** - * @tc.number : HksCryptoHalRsaCipher_003 - * @tc.name : HksCryptoHalRsaCipher_003 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_003, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_003_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_1024, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + "00000000000000000000000000000000000000000000000000000000000000000000000000", - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +}; -/** - * @tc.number : HksCryptoHalRsaCipher_004 - * @tc.name : HksCryptoHalRsaCipher_004 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_004, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_004_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_2048, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - uint32_t dataLen = strlen(RSA_2048_NOPADDING_KEY) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&RSA_2048_NOPADDING_KEY[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&RSA_2048_NOPADDING_KEY[2 * ii]); - } + }, + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000", - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +}; -/** - * @tc.number : HksCryptoHalRsaCipher_005 - * @tc.name : HksCryptoHalRsaCipher_005 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_005, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_005_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_3072, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - uint32_t dataLen = strlen(RSA_3072_NOPADDING_KEY) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&RSA_3072_NOPADDING_KEY[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&RSA_3072_NOPADDING_KEY[2 * ii]); - } - - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); + }, + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +}; -/** - * @tc.number : HksCryptoHalRsaCipher_006 - * @tc.name : HksCryptoHalRsaCipher_006 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_006, Function | SmallTest | Level1) -{ - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_006_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_4096, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - uint32_t dataLen = strlen(RSA_4096_NOPADDING_KEY) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&RSA_4096_NOPADDING_KEY[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&RSA_4096_NOPADDING_KEY[2 * ii]); - } - - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalGenerateKey(&spec, &key)); + }, + .hexData = + "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000", + + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - EXPECT_EQ(HKS_SUCCESS, HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message)); - EXPECT_EQ(inscription.size, message.size); - EXPECT_EQ(0, HksMemCmp(inscription.data, message.data, message.size)); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HKS_ERROR_NOT_SUPPORTED, HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead)); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_007 - * @tc.name : HksCryptoHalRsaCipher_007 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_007, Function | SmallTest | Level1) -{ - int32_t ret; +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_007_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_512, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - uint32_t inscriptionLen = dataLen; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_008 - * @tc.name : HksCryptoHalRsaCipher_008 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_008, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_008_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_768, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", -/** - * @tc.number : HksCryptoHalRsaCipher_009 - * @tc.name : HksCryptoHalRsaCipher_009 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_009, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_009_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_1024, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_010 - * @tc.name : HksCryptoHalRsaCipher_010 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_010, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_010_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_2048, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", -/** - * @tc.number : HksCryptoHalRsaCipher_011 - * @tc.name : HksCryptoHalRsaCipher_011 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_011, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_011_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_3072, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_012 - * @tc.name : HksCryptoHalRsaCipher_012 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_012, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_012_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_4096, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", -/** - * @tc.number : HksCryptoHalRsaCipher_013 - * @tc.name : HksCryptoHalRsaCipher_013 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_013, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_013_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_512, .algParam = nullptr, - }; + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccdd", - HksBlob key = { .size = 0, .data = nullptr }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_014_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "00112233445566778899aabbccdd"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - uint32_t inscriptionLen = dataLen; +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_015_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_014 - * @tc.name : HksCryptoHalRsaCipher_014 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_014, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_016_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_768, + .keyLen = HKS_RSA_KEY_SIZE_2048, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_015 - * @tc.name : HksCryptoHalRsaCipher_015 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_015, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_017_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_1024, + .keyLen = HKS_RSA_KEY_SIZE_3072, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_016 - * @tc.name : HksCryptoHalRsaCipher_016 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_016, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_018_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_2048, + .keyLen = HKS_RSA_KEY_SIZE_4096, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", -/** - * @tc.number : HksCryptoHalRsaCipher_017 - * @tc.name : HksCryptoHalRsaCipher_017 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_017, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_019_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_3072, + .keyLen = HKS_RSA_KEY_SIZE_512, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA1, + .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + }, + .hexData = "001122334455", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_018 - * @tc.name : HksCryptoHalRsaCipher_018 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_018, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_020_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_4096, + .keyLen = HKS_RSA_KEY_SIZE_768, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA1, + .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob tagAead = { .size = 0, .data = nullptr }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_019 - * @tc.name : HksCryptoHalRsaCipher_019 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_019, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_021_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_512, + .keyLen = HKS_RSA_KEY_SIZE_1024, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "001122334455"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_020 - * @tc.name : HksCryptoHalRsaCipher_020 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_020, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_022_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_768, + .keyLen = HKS_RSA_KEY_SIZE_2048, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", -/** - * @tc.number : HksCryptoHalRsaCipher_021 - * @tc.name : HksCryptoHalRsaCipher_021 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_021, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_023_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_1024, + .keyLen = HKS_RSA_KEY_SIZE_3072, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_022 - * @tc.name : HksCryptoHalRsaCipher_022 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_022, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_024_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_2048, + .keyLen = HKS_RSA_KEY_SIZE_4096, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - uint32_t inscriptionLen = dataLen; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_025_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "001122334455", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob tagAead = { .size = 0, .data = nullptr }; +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_026_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_027_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA256, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", -/** - * @tc.number : HksCryptoHalRsaCipher_023 - * @tc.name : HksCryptoHalRsaCipher_023 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_023, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_028_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_3072, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA224, + .digest = HKS_DIGEST_SHA256, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", -/** - * @tc.number : HksCryptoHalRsaCipher_024 - * @tc.name : HksCryptoHalRsaCipher_024 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_024, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_029_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_4096, .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA224, + .digest = HKS_DIGEST_SHA256, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} - -/** - * @tc.number : HksCryptoHalRsaCipher_025 - * @tc.name : HksCryptoHalRsaCipher_025 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA256 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_025, Function | SmallTest | Level1) -{ - int32_t ret; - - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_030_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_768, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "001122334455", - HksBlob key = { .size = 0, .data = nullptr }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_031_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA256, + .digest = HKS_DIGEST_SHA384, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - const char *hexData = "001122334455"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_032_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob tagAead = { .size = 0, .data = nullptr }; +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_033_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA384, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccdd", - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); -} +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_034_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .hexData = "00112233445566778899aabbccdd", -/** - * @tc.number : HksCryptoHalRsaCipher_026 - * @tc.name : HksCryptoHalRsaCipher_026 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA256 key. - */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_026, Function | SmallTest | Level1) -{ - int32_t ret; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_035_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_1024, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA512, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "00112233445566778899aabbccdd", - HksBlob key = { .size = 0, .data = nullptr }; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_CIPHER_036_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA256, + .digest = HKS_DIGEST_SHA512, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; + }, + .hexData = "00112233445566778899aabbccdd", - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - uint32_t inscriptionLen = dataLen; +class HksCryptoHalRsaCipher : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = HKS_KEY_BYTES(testCaseParams.spec.keyLen); + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + + HksBlob tagAead = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob inscription = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; + EXPECT_EQ(HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &cipherText, &inscription), + testCaseParams.decryptResult); + EXPECT_EQ(inscription.size, message.size); + EXPECT_EQ(HksMemCmp(message.data, inscription.data, inscription.size), HKS_SUCCESS); + HksFree(inscription.data); + } + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); + } +}; - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalRsaCipher_001 + * @tc.name : HksCryptoHalRsaCipher_001 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_001_PARAMS); +} - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +/** + * @tc.number : HksCryptoHalRsaCipher_002 + * @tc.name : HksCryptoHalRsaCipher_002 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_002_PARAMS); +} - HksBlob tagAead = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalRsaCipher_003 + * @tc.name : HksCryptoHalRsaCipher_003 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_003, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_003_PARAMS); +} - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalRsaCipher_004 + * @tc.name : HksCryptoHalRsaCipher_004 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_004_PARAMS); +} - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); +/** + * @tc.number : HksCryptoHalRsaCipher_005 + * @tc.name : HksCryptoHalRsaCipher_005 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_005_PARAMS); } /** - * @tc.number : HksCryptoHalRsaCipher_027 - * @tc.name : HksCryptoHalRsaCipher_027 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA256 key. + * @tc.number : HksCryptoHalRsaCipher_006 + * @tc.name : HksCryptoHalRsaCipher_006 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-NOPADDING key. */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_027, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_006, Function | SmallTest | Level1) { - int32_t ret; + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_006_PARAMS); +} - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_2048, - .algParam = nullptr, - }; +/** + * @tc.number : HksCryptoHalRsaCipher_007 + * @tc.name : HksCryptoHalRsaCipher_007 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_007, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_007_PARAMS); +} - HksBlob key = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalRsaCipher_008 + * @tc.name : HksCryptoHalRsaCipher_008 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_008, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_008_PARAMS); +} - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA256, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; +/** + * @tc.number : HksCryptoHalRsaCipher_009 + * @tc.name : HksCryptoHalRsaCipher_009 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_009, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_009_PARAMS); +} - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; +/** + * @tc.number : HksCryptoHalRsaCipher_010 + * @tc.name : HksCryptoHalRsaCipher_010 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_010, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_010_PARAMS); +} - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - uint32_t inscriptionLen = dataLen; +/** + * @tc.number : HksCryptoHalRsaCipher_011 + * @tc.name : HksCryptoHalRsaCipher_011 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_011, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_011_PARAMS); +} - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalRsaCipher_012 + * @tc.name : HksCryptoHalRsaCipher_012 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_012, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_012_PARAMS); +} - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +/** + * @tc.number : HksCryptoHalRsaCipher_013 + * @tc.name : HksCryptoHalRsaCipher_013 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_013, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_013_PARAMS); +} - HksBlob tagAead = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalRsaCipher_014 + * @tc.name : HksCryptoHalRsaCipher_014 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_014, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_014_PARAMS); +} - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalRsaCipher_015 + * @tc.name : HksCryptoHalRsaCipher_015 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_015, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_015_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaCipher_016 + * @tc.name : HksCryptoHalRsaCipher_016 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_016, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_016_PARAMS); +} - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); +/** + * @tc.number : HksCryptoHalRsaCipher_017 + * @tc.name : HksCryptoHalRsaCipher_017 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA1 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_017, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_017_PARAMS); } /** - * @tc.number : HksCryptoHalRsaCipher_028 - * @tc.name : HksCryptoHalRsaCipher_028 - * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA256 key. + * @tc.number : HksCryptoHalRsaCipher_018 + * @tc.name : HksCryptoHalRsaCipher_018 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA1 key. */ -HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_028, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_018, Function | SmallTest | Level1) { - int32_t ret; + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_018_PARAMS); +} - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_3072, - .algParam = nullptr, - }; +/** + * @tc.number : HksCryptoHalRsaCipher_019 + * @tc.name : HksCryptoHalRsaCipher_019 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-512-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_019, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_019_PARAMS); +} - HksBlob key = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalRsaCipher_020 + * @tc.name : HksCryptoHalRsaCipher_020 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_020, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_020_PARAMS); +} - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA256, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; +/** + * @tc.number : HksCryptoHalRsaCipher_021 + * @tc.name : HksCryptoHalRsaCipher_021 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_021, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_021_PARAMS); +} - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; +/** + * @tc.number : HksCryptoHalRsaCipher_022 + * @tc.name : HksCryptoHalRsaCipher_022 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_022, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_022_PARAMS); +} - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - uint32_t inscriptionLen = dataLen; +/** + * @tc.number : HksCryptoHalRsaCipher_023 + * @tc.name : HksCryptoHalRsaCipher_023 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_023, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_023_PARAMS); +} - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalRsaCipher_024 + * @tc.name : HksCryptoHalRsaCipher_024 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-4096-OAEP_SHA224 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_024, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_024_PARAMS); +} - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +/** + * @tc.number : HksCryptoHalRsaCipher_025 + * @tc.name : HksCryptoHalRsaCipher_025 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-768-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_025, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_025_PARAMS); +} - HksBlob tagAead = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalRsaCipher_026 + * @tc.name : HksCryptoHalRsaCipher_026 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-1024-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_026, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_026_PARAMS); +} - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalRsaCipher_027 + * @tc.name : HksCryptoHalRsaCipher_027 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-2048-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_027, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_027_PARAMS); +} - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); +/** + * @tc.number : HksCryptoHalRsaCipher_028 + * @tc.name : HksCryptoHalRsaCipher_028 + * @tc.desc : Generate key and Encrypt / Decrypt RSA-3072-OAEP_SHA256 key. + */ +HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_028, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_028_PARAMS); } /** @@ -1847,61 +1173,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_028, Function | SmallTest */ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_029, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_4096, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA256, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_029_PARAMS); } /** @@ -1911,61 +1183,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_029, Function | SmallTest */ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_030, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_1024, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA384, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "001122334455"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_030_PARAMS); } /** @@ -1975,61 +1193,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_030, Function | SmallTest */ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_031, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_2048, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA384, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_031_PARAMS); } /** @@ -2039,61 +1203,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_031, Function | SmallTest */ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_032, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_3072, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA384, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_032_PARAMS); } /** @@ -2103,61 +1213,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_032, Function | SmallTest */ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_033, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_4096, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA384, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccdd"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_033_PARAMS); } /** @@ -2167,61 +1223,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_033, Function | SmallTest */ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_034, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_2048, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA512, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccdd"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_034_PARAMS); } /** @@ -2231,61 +1233,7 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_034, Function | SmallTest */ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_035, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_3072, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA512, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccdd"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_035_PARAMS); } /** @@ -2295,60 +1243,9 @@ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_035, Function | SmallTest */ HWTEST_F(HksCryptoHalRsaCipher, HksCryptoHalRsaCipher_036, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_4096, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA512, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccdd"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - uint32_t inscriptionLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen + HKS_PADDING_SUPPLENMENT) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - HksBlob inscription = { .size = inscriptionLen, .data = (uint8_t *)HksMalloc(inscriptionLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - inscription.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - ret = HksCryptoHalGenerateKey(&spec, &key); - EXPECT_EQ(HKS_SUCCESS, ret); - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(message.data); - message = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - ret = HksCryptoHalDecrypt(&key, &usageSpec, &cipherText, &message); - EXPECT_EQ(HKS_SUCCESS, ret); - EXPECT_EQ(inscription.size, message.size); - ret = HksMemCmp(inscription.data, message.data, message.size); - EXPECT_EQ(0, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); - HksFree(inscription.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_CIPHER_036_PARAMS); } -} // namespace RsaCipher \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp index 63f8dc0c..a675f29e 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_decrypt.cpp @@ -22,278 +22,80 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -namespace { -const char RSA_2048_NOPADDING_KEY[] = - "0100000000080000000100000001000000010000a0286e22fea334e1ec2f48a955d91d44992e2fda06d23ff00bbfdd70f0f961bed02781" - "e345ad866f63c217ae82f84db6f3ef2d5937fe9684f2c1e1ac091e81eb7dc1da7bb4a2ad7e3bb2911cfbfa8c0244527b91259b5b7ac1e4" - "32701ac4e5c87186b59340ae0b67e4d2805ad01431121d907181aaac1d7a26e4703b1812c711fa3d056a8f4709a923193895f2657e66b0" - "b109dbc65c9703bc08d79696f35f63e790aff9cf4323320288d5bc9360f08dc9576d7cba0792bc56864a844b72c49041340b8b3487dba1" - "f724bac429e7d40c99d752d4be9cca352b59a7594ddae02784c3b8e137f141e2a77e098524aec3b96d989fe09e28578fabeb6e6976bba3" - "77000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000100010490024b36ebd956d24eaa88406cd5fb9d4d" - "868974864ad200d3af70473d237eb7195906eb763d0d314f57335e81ca5cfae80667b343aa7011265ad276d40aa975c4aeffb52ea9389e" - "64c0e38d7e1ebcf5cb4fbfdbcd6836c00d4b2e8c64ad931f40d22d66bb4e91e01feb0e2b3d580487191552b754fde5fbf3a80ad6edba04" - "0a8d0c30fa413ce7cb7d1bdd5960cb6d9c68285cf7ca8abde4c2a5aa2f7ef875e66094b9a263e529f38651f405ee9410ae45f3f272effb" - "d318c23eb112bb295b79cfff9f5df4ed2a91c590c03fdb304e74dd7758916b91e4716a6b4f5703516aaad8a8cb9f2b603f11ac90b0e941" - "ffdf7059c7ba1a74c5bf6435a8040f175ae1"; -const char RSA_3072_NOPADDING_KEY[] = - "01000000000c0000800100008001000080010000b3c325e9339d6cc17db61da704dc05364320f4ca208467ddbf3d44a625a5dc3a6cd134" - "27cce14a3f0a2f7a50a6e377b52f73bb824254d8bed785b91303f30211c20d1bef9ddd5e4ee88b7425ef2846f41e791d5a9670682553be" - "ce2dbf41d88abbfde7dc3f450572290daabb55a1a56b28b282de9576249de95d0075d47914943f52d9a559ddcec9b5f610eeee9bf10cd3" - "d807d00abdf94e7f63a50d01ddb8cff95e0452e56e614115031fe5ddb91d46c13358c1f42685fc19e09a2cf3170fa0bf0e0a380400fc8c" - "c3e2f287c68d48ae04ecd3448273198744f37187eee774cc2dcc28fd3b037af7f4c54e30dd254c12b6f482c32e2de7014fb48f5badfea3" - "91531b6a58c1c95f84ded943cc8fe113ff21e3c5f5625d88c77ee24ecad6b22e0013831af764c2a87c7db71062b922c136402a102391c4" - "911bb286e8d96efa8e1c629d8818fd02de45bcdb8352cf16af7f282e5676a4b07c74a7e52b94726963fb79f433991114415474f90b10e3" - "fea5d24043ce964298a938aa79014ae98da4b3000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000010001546d4714ebc4f81b382b9c69a102a500032f2b48f354bc638d39fd4ffb4696d469df279bb9" - "c1e5d90db396c2e25edb0e21a73d5dc4418d3ab4867d91ccbd092fc5efda3b03edc029575687ca7934757e9a015024079beb8dfc7314ea" - "af75017ac7284d09483de67ce38323b8b0532719d9175e17a422c4b7d5ae7454e2e1ab24a54908277cb98c317860853b729d92ecef61fa" - "e95ee23281079b891d3ecf1fc9add8d63708c27ab2d2679147a8871494f290671350d3f7019c35bcb377c850f1e87dcc174873ecd98d0c" - "f6ed9dd83118142d9f9cef1301b221a047440609ac3be88bf69e8e50843f75c855f974dc00e18168c8000a9a4ca65247560a5187ffed04" - "4eb4da9e4e517870ab2dcbf6574c63676f8a3620852940c6b185186d21a53bdb20e7bf7d16288a3d9e0d47844d2b605f8ba879e87ce348" - "033667577d6c91645f30f2720e9f9229ccc7a270215b124677650e94e5c181cdac04e2b2dfb8c3165f3a4a556c78684f60e602fb79f911" - "68a938c5f0c4254265ae72f54938268021"; -const char RSA_4096_NOPADDING_KEY[] = - "0100000000100000000200000002000000020000e5a087382ce37175f66f6e4ebc00c0cb7d9b0486425eed1bf831cb43566031894221a1" - "f1b0c7275318d82b186640256c3f1325f32a740e2c9ab3f7ca866d02b982f9caaa59eb49d7e3268f6b902e589ec65c91164d1e370ec407" - "b06f9687b059835574ce9a541607b08e18a33fc74ec9ae0bb7e2a3c1fd73eeffb493e2e939b9ab7501dd0692ac63d262cb4130fae6be54" - "42964a80f3e7474c0fee48dce2940e7fae7a8a8aec30a8d71dab54b1d42b1a364fc60a837f2533ca79dec02796cc00202db34dfb674641" - "d20aa00c1d748aae18f5219ff5232a479e4e61a653c54b84ec1fbbd16624d595af1bb831508af96f02494312e46bcccca9e8c6f471c082" - "c7a2e742a239cb908279b63f29385d53172ece4a85272acca9e52b9599c244a6ee786b7ddb599c198362bd5697c522f667457c11503286" - "4e4364325873652f9e69b27aae8b1c8c385164c8edcdf401dc306ade1907449bd1c58593681b5f8e8cb536c9e60390152ce648ada0f091" - "d3b11ca660f44421257434b69f4f60a6159cb86c8911559319e765550d142d58e844896259f0e8eb471a2150a79221c31d0b2032b3d716" - "b3c00255eb300fbb2fba4bec0d4041d7b010939fd339e8080d52c7ded936af229358a580ac87518bbd785fb103534b9ad3f19501125b5a" - "9467d4b76e5e571d2b1393454e92711be52d1f9482f7997f4e65102995874febc087792b77000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000198" - "f34d3e40c01ac22d2cd9f7bdc86ea2dc7e560c2bc758fe695a997eb7d90905d933d7cfca254d6f4f3c25b071e3464a0cd56f50c2355d7f" - "9e6843a3f5d8449956c19599d49d21a9985705eeeab1c43bb5fad0755f56c1eba6ed4c3b77b3d7e637d1c3251eace5a3a7996e95c694b6" - "4926120e20fb5ceababf36398ccbf6f78951c8753e48f387ba51d796754cefc2a482317c341222e4299c637c1fb269859f06b32c527de8" - "871cdf7496bbaa5b9d7e2f3101c3dd04e2bdd59f499d0a81aa4e6720a9af46c6ea884b24e2a84f3262714694791a37c97d8f08c642caec" - "3f9d66e374dbc0c5ddc11a9bf1c5c5ab557681d7aefeeb6594dc6c72bc67514937a6a399d80094486382538c330569a3a944375751d9eb" - "ed82c39bf81cf27f88c211070960d781719fb64d3c7a507c955e015cd3c4e968fea4d999d57245b30bcffae2c44ab6bfe4d2c3d7457a68" - "3f0580cdc0d4910e071ef624888db604f110eb6aa2a454cd9b74d4b9b857994452c092c20df2a0110ed81c8275aa745971e900c9485f67" - "82fbf666215762f2f971e4d213be05cb1760e4c7bfc3fb17ae1409039568ba3d9e2d34e282cc43c9db4ed8286a0a504022cbd23cd68cc7" - "94685dd6daddf1054673cb9b517495e0c39569e0627e4b8ef80bb196f58f53627af0a4142fb2b469cc767a348ce74ea8dbdc647386e485" - "62a124488021988f9d71ff68f2028a19"; -const char RSA_2048_PKCS1PADDING_KEY[] = - "0100000000080000000100000001000000010000ddf3e9c6589658e5c124a49d473db529e8eb08b99c351cf7c5d502f64def9752d4ee88" - "d942cbdbc7fb46eac9d9b9f9b309fbffa99c9fe05363b2d5e71c2d132bc83d74f0b8441266fc2f6f0462b54fa0ffaef92bb93cec2d1805" - "9db40ff9d579f7980c08cb9a30d076d6ebf50f4166514bd00cdf20ca042ddf13581feddd32b15e8508f2b185f4e6c77217c5096a9dfecd" - "5132ee4ce41bccd3faa75abcf1014e5e27328d3a1b08e56c33d5f5f2fe8b8f232db6953a337bca29e2726165732c8d1aae10a6e9c60ce5" - "4b2423868e6d024dfdfab45fbb3d589d06fb8f55564bdc2bb07c1c84cf8c076045706b36e6715c4dc8cd1f4fe751de77b031b5bcf7cde7" - "41000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000001000151ac53b5fd1b361335837a5fb5bb6b52c4b6" - "d83b14d42698b65faffb5aaa7390b37223416f66fcb5162dfe6fd082b2f3c314cbfb69fb1add14aed62f791acd172b54121812765a1f33" - "657100b821e7ef62a6cc61de842094676689a59ccb5e56c75957f45497a4a6d1543cf7ac69707131e89913f248e448ccf19d58027b870f" - "361c57bc60e75da62e75d94b7e42c544e7ef183fd1935f0ca8d637e18cc4acae0e99f8aabbf83c968460b5237eac3271f214fd10580166" - "c836e067948438f8a3c5edded4871baf6acab762e501db5fde6f2ec201072532c109d0a55cdf0e275322ccf326c9a2a6b235d5742067b6" - "f7912bf772c9039385ab0a81c0186bf91001"; -const char RSA_3072_PKCS1PADDING_KEY[] = - "01000000000c0000800100008001000080010000b6267a0a854bc91d6a7f469ea9212dc3fb2a5a2e6626ec1f41e3f6436361b0c8141bcc" - "77e3e568dfee0068e0c863681ba0383b22046e6ef166274cbe19893e8a0ad4fdf86475998b0b00af04ccb0d1e1b42f89a20f56dccbfe14" - "45e794a8123434a252eab9e386a35d663669d219b34ad92f7a64a90a91f25ffa002ccc589843fde8cb3111d566b4a665c51d801f290ceb" - "be980ae71fad125e851c426d240fa361414c34a037d2a0840a25e4af4355931a6efc7c9faf11a5e8d225387965ea51f81f910786b9dfa9" - "8459678db6a0670b14b64a2be05ebd2db0f25fcab225f719b5cd97a0f38c490d38a710d594d50ba75ab0ebc04456fe12514f96351cdc9a" - "8a868389c932b3572726ce2303ab1e7f85c43c18e52ae14efcad4e0f65bffbf3254e10ad616ce169594373dcf1d44016c4fd77023bb0a8" - "302ce72de9ce1aba9d885c05aefa935492592afaae543c8c99e997dff2c1125a3931f5897b5ce2c6217d69be0d74612dea66347c076c44" - "5849c786e36a0c285e0f3b838d630b3347a96b000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000100013f242b5e0642f51e6b525f6a947a59e0fbe9fc84e5084d05b0d393045d28fa1d014b799f7d" - "b2829e4d647af6a0c044d07ec3bf4bd5796a9fe7a76be4e1f93f629ecaa2973e4bbdc40336637528778ae9d08a420d997fa4de59df3134" - "4bc5cf39a59d375d02bf2a66eaf3899d39258b8f40a642a92e27e9dbb905729614e80930588e20118c7b0b35481133393cb69086581a23" - "9e73ebf914cb0b1d76b15ab4c90fe790c1156104747c11007dbb7b7de8965b2ecf0c93a56c7bbe8d047ca0a58edaa75649497e7a4c1b69" - "90a9d6fda6dcbf9732d517a01a3818287c8717949fa4820d88f3a5918bc0d629d88ae63e1b9ba0a52bd8cefdf30e4b273e9ead163dad87" - "bafb456b7af8b8e5dc353eda84195190b994e447758f082c1d9700d83655f1956f1c75dd5cde9880169b7f7720cc39761411a3c98cb25d" - "ce939c5c1724c07f31a1bfb59771d06cee3c6057e04489ceec6a122866d67d19923c7c5cbf598e48ab4fede639807b9d3d6f83aa821411" - "94019bc2c4fd028ccca7dc4e56e657f931"; -const char RSA_4096_PKCS1PADDING_KEY[] = - "0100000000100000000200000002000000020000c214a594a87457faccdfa9e466160af3a292f93003783fa46feeae2d84c0c41704d01a" - "2eb9874b59fcd217d7394e01e20a9fd162ef4de6c87adc11d423bc13c1f2b609e73c5ff20251a7e9e940fdb2fed3e8d04a2dc5fd33708e" - "aeea6b85ea021487daa0d8cc52b1ee0299915a5dc5b469792908aa05bad12d4c1af13c5ab552849c480ac6bec9fd4256d2b2b8f4f48583" - "f471c8f9e3c099c170e4863f5935ae11475d45bf4a1c5022937c31cdb23379f3bdbbfc8f59cce6dff3b02f201f660640605c9cf9f489da" - "74d378f9a97cc1284662346fd78f621c7b36b15b60cc5d645b5217a5aaee9f4c5f0cd1a3ba6d4fcfc49e472951e300af124106f38fc10f" - "3e40812997b93c35e44e8267e5d88bb0fba1e941801ee360317d1b4be71e40332d2a44c8727f7ae36eefe83906b4bc44214f126882f03a" - "9856e08268784c39fa351a7a00fbe916c2279ca679d7fa39a386e7ad50a08511031a480ffb449928b8e6b729921671f882f85dffbea3b6" - "93c362c311cba5ab909f06c7e2e333d11ca9ed0a821f4029101788071471236bd7af5a6e84ee6f5b7010a35ecd4abc894db5e5283322e7" - "5ef6f539d8a1524f155a7d2da825f42b11b80358d806d28934ef73014e863eeca74156d4b1b066ae11a875b746164095ed815b10478a37" - "cae6fa96fe16e9833397270fd531f7c1a9cfae0caad254e3b659e37e3fa9a1dcf07b48e101000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100012f" - "99f4cab34e65cdc3b60feb4f0695051098cfb971006b4b9f9080f3f51d7a7ad2d95fb29a1a8ee6b155ae37417cda856069b667779e39be" - "6e33cfc3a2481ce872e92720a9f4365d4f3dc9e745e373a580c017663a37d7546884f66dd49571c1b4db654a12227b1ddcec9251ce4235" - "9d7c49154164c22701eb04418f6d682a14e525979ddd052a718d75d213b7bd8cc3ba8b97e4dd357925bd063d6697deff85840366e31679" - "ccdbf2bf0db5016875abb19695a6ea59f221a64814ac5a4a99316b54b722614413139b97ca922179d1be5914f91b7d59538cfcc37b5898" - "3347acb7a138df8f3f1b9f15a9053a0d1d8677c517b508736723e1ccae5a501eb011569bd1d1dc71f75681c5871497a149bdd4c0cfe7ca" - "acca439faba11526aee5f280345555c81f09213e6d6699511cece3dcb1ef47694c3d2eada01653d565dd0f85a56b9bf35ed63f1dcffdec" - "73939a2bd962f67feb49aeca0395214d7d2430b6a9c43a93f49386ee99579a46ad9848138ca08c0c02c4036f538f41b708bd1ce3be00c6" - "4caff64bfbeafe65d19b245f3547b999d84163e51c200b91b762728e43d5eace6ebec90119be092ae6f131ea7b5d5901eda3b8cbca01f0" - "df7f98dc3aab37712c3b223d03510ce241cb81e5719fb8ee161a1346d8323397d2ab673695d5d08816f1c0fc61073eb33471d29d7ecdcd" - "083678709efd4b63e5f0a699ec19e949"; -} // namespace -class HksCryptoHalRsaDecrypt : public HksCryptoHalCommon, public testing::Test {}; - -/** - * @tc.number : HksCryptoHalRsaDecrypt_001 - * @tc.name : HksCryptoHalRsaDecrypt_001 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_001, Function | SmallTest | Level1) -{ - int32_t ret; +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; - const char *keyData = - "0100000000020000400000004000000040000000ba5395c32972cdd04061fc45ac6d501555110a32300d44f57d6d7d9b478888361d815b" - "45c30aedce3674cf440c455552ba05ea9ef4659f37077c9498541f79d10000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000010001355e09702ba801411b9fb514f3ad1f99ec" - "9283dc1a1d42da1981c9cf36eee92c3154e0b65cd6653c01a0568dec5f969bf6581ca2aa3c572138cfc9a0b2b3535d"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + HksErrorCode decryptResult; +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_001_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "4af9454165afd9ad50635a7f18858dd3693a9713604971572824fff91cee16fb80169977eb1a91afe8e2ad401e1" - "bcdec93f8c6c5f1398432ee35bd5865a70a1d"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); + }, + .keyData = + "0100000000020000400000004000000040000000ba5395c32972cdd04061fc45ac6d501555110a32300d44f57d6d7d9b478888361d815b" + "45c30aedce3674cf440c455552ba05ea9ef4659f37077c9498541f79d10000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000010001355e09702ba801411b9fb514f3ad1f99ec" + "9283dc1a1d42da1981c9cf36eee92c3154e0b65cd6653c01a0568dec5f969bf6581ca2aa3c572138cfc9a0b2b3535d", + .hexData = "4af9454165afd9ad50635a7f18858dd3693a9713604971572824fff91cee16fb80169977eb1a91afe8e2ad401e1" + "bcdec93f8c6c5f1398432ee35bd5865a70a1d", #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} +}; -/** - * @tc.number : HksCryptoHalRsaDecrypt_002 - * @tc.name : HksCryptoHalRsaDecrypt_002 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_002, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = - "0100000000030000600000006000000060000000bb715e35d0c13b8c2a283017fe1adc3b38d74e8c1870a2ee3c04a25ba9d4ee332f3210" - "8eb7d7c46cf78f88080b64703ba7732592433e8598f4e693d16461ab58284a72a0a9a2df470514369f19fbc7b6a4f0c14e5d2dd289f630" - "e263d4907c3500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001269b10e6509a9be3" - "2083aa742697eda81ceaeb789b4807a6bda1ceb6c661deb59810ddac275d3f4d9a276bc30c65a15fad040d4a41991680ccbf5127548bb6" - "153ef468283ba702d8a13655ab5a6c73b6d3dd5accf567a3231900e138af224641"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_002_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000030000600000006000000060000000bb715e35d0c13b8c2a283017fe1adc3b38d74e8c1870a2ee3c04a25ba9d4ee332f3210" + "8eb7d7c46cf78f88080b64703ba7732592433e8598f4e693d16461ab58284a72a0a9a2df470514369f19fbc7b6a4f0c14e5d2dd289f630" + "e263d4907c3500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001269b10e6509a9be3" + "2083aa742697eda81ceaeb789b4807a6bda1ceb6c661deb59810ddac275d3f4d9a276bc30c65a15fad040d4a41991680ccbf5127548bb6" + "153ef468283ba702d8a13655ab5a6c73b6d3dd5accf567a3231900e138af224641", + .hexData = "ab3c8dfe0cc42bf5176514913a146fe5466bc317344e073de2c5af055961f04d1cefb563a0c478121f74a23b561a7d6f2bca77a59b5e03" - "669955ce3d320925aee431712eeeac08b96e346d0a59ca94f3780768915fb885e09ce81dd7b5490527"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); + "669955ce3d320925aee431712eeeac08b96e346d0a59ca94f3780768915fb885e09ce81dd7b5490527", #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaDecrypt_003 - * @tc.name : HksCryptoHalRsaDecrypt_003 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_003, Function | SmallTest | Level1) -{ - int32_t ret; +}; - const char *keyData = +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_003_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_NONE, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "0100000000040000800000008000000080000000a51514cb129c6e19e50eaf764e08067e5720ba300a9031a5a40509d210b0e5a072b7dc" "6e0b9da82b59bb5c41b0baabbd4b534eb6a8fd50c25a7d9b7b1c7d9e808c5de65a0658fbb353b635dce78ab6d09478257b7e8b5b508cd7" "5a735ca3944aba2bc8f443cd9ed6b0096cfda268e2fda1462182b313b25f27ecdc4510fc87770000000000000000000000000000000000" @@ -301,193 +103,145 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_003, Function | SmallTes "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" "016671c4ab98eb16b05f2353e3d8dcc61ad53aec10301df791514e0720235783c8a4285154c1449f3df7bb7baf105b67845b2061b29d00" "4683b5e049028755b56c15879f4b5dc76e57fd0296c1286b347f7387b2f9e8cee0fbd6cf034cd16dffa6cc2f5c1101c1f430c265ea0d5b" - "c27a01672405d4f670baf194ccb4ba87a3c5b1"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_NONE, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "88455132d720d77b04128a201f6c1fa234568c368cc4f57d1381316c80e32d3874f5a30f2be6cebbb960ef2a526" + "c27a01672405d4f670baf194ccb4ba87a3c5b1", + .hexData = "88455132d720d77b04128a201f6c1fa234568c368cc4f57d1381316c80e32d3874f5a30f2be6cebbb960ef2a526" "3801b9c2b98261018b3bbe93e97908739f65be688432a89d1851c45c1d7b02d881db53750795450811f28ce538c" - "f80729ce6f455fc059705e5d120d48280fbbe331226c53fb14293f92351aff3dae32b05d64"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); + "f80729ce6f455fc059705e5d120d48280fbbe331226c53fb14293f92351aff3dae32b05d64", #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} +}; -/** - * @tc.number : HksCryptoHalRsaDecrypt_004 - * @tc.name : HksCryptoHalRsaDecrypt_004 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_004, Function | SmallTest | Level1) -{ - int32_t ret; - - uint32_t keyLen = strlen(RSA_2048_NOPADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_NOPADDING_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_004_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000080000000100000001000000010000a0286e22fea334e1ec2f48a955d91d44992e2fda06d23ff00bbfdd70f0f961bed02781" + "e345ad866f63c217ae82f84db6f3ef2d5937fe9684f2c1e1ac091e81eb7dc1da7bb4a2ad7e3bb2911cfbfa8c0244527b91259b5b7ac1e4" + "32701ac4e5c87186b59340ae0b67e4d2805ad01431121d907181aaac1d7a26e4703b1812c711fa3d056a8f4709a923193895f2657e66b0" + "b109dbc65c9703bc08d79696f35f63e790aff9cf4323320288d5bc9360f08dc9576d7cba0792bc56864a844b72c49041340b8b3487dba1" + "f724bac429e7d40c99d752d4be9cca352b59a7594ddae02784c3b8e137f141e2a77e098524aec3b96d989fe09e28578fabeb6e6976bba3" + "77000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100010490024b36ebd956d24eaa88406cd5fb9d4d" + "868974864ad200d3af70473d237eb7195906eb763d0d314f57335e81ca5cfae80667b343aa7011265ad276d40aa975c4aeffb52ea9389e" + "64c0e38d7e1ebcf5cb4fbfdbcd6836c00d4b2e8c64ad931f40d22d66bb4e91e01feb0e2b3d580487191552b754fde5fbf3a80ad6edba04" + "0a8d0c30fa413ce7cb7d1bdd5960cb6d9c68285cf7ca8abde4c2a5aa2f7ef875e66094b9a263e529f38651f405ee9410ae45f3f272effb" + "d318c23eb112bb295b79cfff9f5df4ed2a91c590c03fdb304e74dd7758916b91e4716a6b4f5703516aaad8a8cb9f2b603f11ac90b0e941" + "ffdf7059c7ba1a74c5bf6435a8040f175ae1", + .hexData = "1b0e0e20bdc554668442cd2c319ff6141c40a33ad6fb84faa9d464f489260b0ea97618c3bd5c7a83aed8d8b7943f32fccb66ddeccfdcd6" "7890efe8a1eb68a45d8b0750c6512aeb2d5ff4d146ed343f8b13def65ac7cc9c7f5ec3b6deaf7f393ece7b29de191dbabfcc1f7ad7e77a" "8a199668eef72cf46b54a443804f3cccda2864edc45d899070fc9227368ec73195cb4822509653c822a73d0200b0470b9b70aa549c16a5" "2d43e5ed3975f5762762949590e7d27849939590febed7c0e39ac57b2bfdcb982cec8048de669d2c00095ca8aea66388f8be1403fcba33" - "754df4343ce0b7cbab26f5b43f595c9abe50c79a6876167fe652bc632cc1f341e1e21f8d"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); + "754df4343ce0b7cbab26f5b43f595c9abe50c79a6876167fe652bc632cc1f341e1e21f8d", #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaDecrypt_005 - * @tc.name : HksCryptoHalRsaDecrypt_005 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_005, Function | SmallTest | Level1) -{ - int32_t ret; - - uint32_t keyLen = strlen(RSA_3072_NOPADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_NOPADDING_KEY[2 * ii]); - } +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_005_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "01000000000c0000800100008001000080010000b3c325e9339d6cc17db61da704dc05364320f4ca208467ddbf3d44a625a5dc3a6cd134" + "27cce14a3f0a2f7a50a6e377b52f73bb824254d8bed785b91303f30211c20d1bef9ddd5e4ee88b7425ef2846f41e791d5a9670682553be" + "ce2dbf41d88abbfde7dc3f450572290daabb55a1a56b28b282de9576249de95d0075d47914943f52d9a559ddcec9b5f610eeee9bf10cd3" + "d807d00abdf94e7f63a50d01ddb8cff95e0452e56e614115031fe5ddb91d46c13358c1f42685fc19e09a2cf3170fa0bf0e0a380400fc8c" + "c3e2f287c68d48ae04ecd3448273198744f37187eee774cc2dcc28fd3b037af7f4c54e30dd254c12b6f482c32e2de7014fb48f5badfea3" + "91531b6a58c1c95f84ded943cc8fe113ff21e3c5f5625d88c77ee24ecad6b22e0013831af764c2a87c7db71062b922c136402a102391c4" + "911bb286e8d96efa8e1c629d8818fd02de45bcdb8352cf16af7f282e5676a4b07c74a7e52b94726963fb79f433991114415474f90b10e3" + "fea5d24043ce964298a938aa79014ae98da4b3000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000010001546d4714ebc4f81b382b9c69a102a500032f2b48f354bc638d39fd4ffb4696d469df279bb9" + "c1e5d90db396c2e25edb0e21a73d5dc4418d3ab4867d91ccbd092fc5efda3b03edc029575687ca7934757e9a015024079beb8dfc7314ea" + "af75017ac7284d09483de67ce38323b8b0532719d9175e17a422c4b7d5ae7454e2e1ab24a54908277cb98c317860853b729d92ecef61fa" + "e95ee23281079b891d3ecf1fc9add8d63708c27ab2d2679147a8871494f290671350d3f7019c35bcb377c850f1e87dcc174873ecd98d0c" + "f6ed9dd83118142d9f9cef1301b221a047440609ac3be88bf69e8e50843f75c855f974dc00e18168c8000a9a4ca65247560a5187ffed04" + "4eb4da9e4e517870ab2dcbf6574c63676f8a3620852940c6b185186d21a53bdb20e7bf7d16288a3d9e0d47844d2b605f8ba879e87ce348" + "033667577d6c91645f30f2720e9f9229ccc7a270215b124677650e94e5c181cdac04e2b2dfb8c3165f3a4a556c78684f60e602fb79f911" + "68a938c5f0c4254265ae72f54938268021", + .hexData = "51873b08dde7e0c840d341d0785a26d4f7fc5c4c8cfedb2fd8e0537720a8b680205d8068d37d0fccb8e3825e73aa33bd0daa911a1a1bf1" "5fa4d87cb900600fb5914d2dc8f6b7e00497abc3308657b00fee8505a3340011f46817f8111bdb839888ed1fa2e9a9f8fad9480557a8fd" "8d49d255e3b01e5fad00233a65605fda776909338fa3f806513ce02d535ded88170721d4635c03c7e2907fae9227991abbcaffc28cc462" "4918571861aaf53796f7716aebb946051b312364fe358a6849685b87bc0a5373cbb95760001a958fbfa089df9157b66721fab189df5308" "28292409494909a8b3f3aca7d909c88bce75c1a41cc3a639f7ed4cd018b6187faefa4b1c8362e754b2571b0b7f8d208ce81305dcb35d89" "e5ec2eb8e3a5690c26c8eb9b84ebd9b1cb3c652f2e70c5a3d7621925feed1441d88a31b4e2f927c9825409ad4396ed81bdfbb67bd2892a" - "5246e915663e0210c0abdc0ede5f6021d37561893e7342a30c0609c04708be29f13737b98d1969b7b56c48d84ab6d854731bf299379e"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); + "5246e915663e0210c0abdc0ede5f6021d37561893e7342a30c0609c04708be29f13737b98d1969b7b56c48d84ab6d854731bf299379e", #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaDecrypt_006 - * @tc.name : HksCryptoHalRsaDecrypt_006 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_006, Function | SmallTest | Level1) -{ - int32_t ret; +}; - uint32_t keyLen = strlen(RSA_4096_NOPADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_NOPADDING_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_006_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000100000000200000002000000020000e5a087382ce37175f66f6e4ebc00c0cb7d9b0486425eed1bf831cb43566031894221a1" + "f1b0c7275318d82b186640256c3f1325f32a740e2c9ab3f7ca866d02b982f9caaa59eb49d7e3268f6b902e589ec65c91164d1e370ec407" + "b06f9687b059835574ce9a541607b08e18a33fc74ec9ae0bb7e2a3c1fd73eeffb493e2e939b9ab7501dd0692ac63d262cb4130fae6be54" + "42964a80f3e7474c0fee48dce2940e7fae7a8a8aec30a8d71dab54b1d42b1a364fc60a837f2533ca79dec02796cc00202db34dfb674641" + "d20aa00c1d748aae18f5219ff5232a479e4e61a653c54b84ec1fbbd16624d595af1bb831508af96f02494312e46bcccca9e8c6f471c082" + "c7a2e742a239cb908279b63f29385d53172ece4a85272acca9e52b9599c244a6ee786b7ddb599c198362bd5697c522f667457c11503286" + "4e4364325873652f9e69b27aae8b1c8c385164c8edcdf401dc306ade1907449bd1c58593681b5f8e8cb536c9e60390152ce648ada0f091" + "d3b11ca660f44421257434b69f4f60a6159cb86c8911559319e765550d142d58e844896259f0e8eb471a2150a79221c31d0b2032b3d716" + "b3c00255eb300fbb2fba4bec0d4041d7b010939fd339e8080d52c7ded936af229358a580ac87518bbd785fb103534b9ad3f19501125b5a" + "9467d4b76e5e571d2b1393454e92711be52d1f9482f7997f4e65102995874febc087792b77000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000198" + "f34d3e40c01ac22d2cd9f7bdc86ea2dc7e560c2bc758fe695a997eb7d90905d933d7cfca254d6f4f3c25b071e3464a0cd56f50c2355d7f" + "9e6843a3f5d8449956c19599d49d21a9985705eeeab1c43bb5fad0755f56c1eba6ed4c3b77b3d7e637d1c3251eace5a3a7996e95c694b6" + "4926120e20fb5ceababf36398ccbf6f78951c8753e48f387ba51d796754cefc2a482317c341222e4299c637c1fb269859f06b32c527de8" + "871cdf7496bbaa5b9d7e2f3101c3dd04e2bdd59f499d0a81aa4e6720a9af46c6ea884b24e2a84f3262714694791a37c97d8f08c642caec" + "3f9d66e374dbc0c5ddc11a9bf1c5c5ab557681d7aefeeb6594dc6c72bc67514937a6a399d80094486382538c330569a3a944375751d9eb" + "ed82c39bf81cf27f88c211070960d781719fb64d3c7a507c955e015cd3c4e968fea4d999d57245b30bcffae2c44ab6bfe4d2c3d7457a68" + "3f0580cdc0d4910e071ef624888db604f110eb6aa2a454cd9b74d4b9b857994452c092c20df2a0110ed81c8275aa745971e900c9485f67" + "82fbf666215762f2f971e4d213be05cb1760e4c7bfc3fb17ae1409039568ba3d9e2d34e282cc43c9db4ed8286a0a504022cbd23cd68cc7" + "94685dd6daddf1054673cb9b517495e0c39569e0627e4b8ef80bb196f58f53627af0a4142fb2b469cc767a348ce74ea8dbdc647386e485" + "62a124488021988f9d71ff68f2028a19", + .hexData = "8b8c55416c4fb052ead30f042c39e66c512b002c0b38a4fb08f0ebd7c78b2f231b16793e857738b0b1a6d6d198a95aa1acf8c85e997ab1" "2e1c6cf1fdaf2016adea6d6b54b972452154566b1ac786c71ef199f9e50ae35dbe5196a12b0bcfd746cb72d93eda34418f3cd73189acb6" "03a4ab6f05d0f08318c8b48128e23cdfff529eb1fd9c6a3a64171711981d568bb93166f68d9a8eed44a8040bf0f703853c337dcbaddfb4" @@ -497,147 +251,68 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_006, Function | SmallTes "d28b3d49e3b2dbfa117dde77382ac541f0a1e5156a528a393ce4554875216bc254fe9ee1d5b5cb693440eaf00adb4a1e1537376480b448" "9a8e717a5d565fcadc561e14e1a74fbf779a6348ba1ff4548c35cddc49829b9dd4611fc38ac80b840fb94411982124d8ffa270825c3ab8" "63c732cd4b81db68fcb901370b8ebf0075fc8f64c8faa17ca19ac7fc0fef63510ff2dbebb0954649ac380bdce1657b4ee32470c3077129" - "afdd319c966fa39b05bd8faa05a16a87f1"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); + "afdd319c966fa39b05bd8faa05a16a87f1", #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .decryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaDecrypt_007 - * @tc.name : HksCryptoHalRsaDecrypt_007 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_007, Function | SmallTest | Level1) -{ - int32_t ret; +}; - const char *keyData = +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_007_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "0100000000020000400000004000000040000000a6a29490a5a6b309192f7571daa7cacce05dc5a5af6e4c0648ffc3dd72704651c806ee" "0cb61afc2f118bb24075a2f303cc548bfd9fea2c3dc945d5d976457ae10000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000100012a295cb9b4901720a834afdc9cdc739d9e" - "ef5b00ef0053500bcc5afc7ee6158457279c58942bafa28d436be509cd30b841e40cb769efffe8723b70c6f464f599"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "ef5b00ef0053500bcc5afc7ee6158457279c58942bafa28d436be509cd30b841e40cb769efffe8723b70c6f464f599", + .hexData = "0716c17114c78dc6000d72b612174e6ac6b42cc2b7aeeb3651dffc92741a6396360368cc8a3f43629a78ef56231" + "89708b4cc75a244c46235793c2d6bfe1dbc06", + + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_008_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "0716c17114c78dc6000d72b612174e6ac6b42cc2b7aeeb3651dffc92741a6396360368cc8a3f43629a78ef56231" - "89708b4cc75a244c46235793c2d6bfe1dbc06"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaDecrypt_008 - * @tc.name : HksCryptoHalRsaDecrypt_008 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_008, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000030000600000006000000060000000d056e8b387700c781feb01097ecd9868c32af0cea33292634b2b0027117b75af0ebdb9" "6172c776ef95bb7c3dcfa6126858e6fe69c87e0ed69dcf81e15ebef50f03fbaffaee527c291f3740e521730271eb3b63f4057cba780c6a" "c8520816d79300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001acbf7361f12a5a5c" "7c72bac069d105cfd00c59f1ace630f57e0d60aa0457ef63c10055a754a9c997acfaf170bb2dc3d21b8e26541ba01ff0b99788b13a553b" - "f97c8c71cd149dcb421fb96affc55a6588adb642251bd991ef7d54890950e5b719"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "f97c8c71cd149dcb421fb96affc55a6588adb642251bd991ef7d54890950e5b719", + .hexData = + "3d6968c44be17c9379d982a739429424e24c30dda87732d9858efd0ed43a43d2e5abad0bb2a84254700b6d2c3f41a7fb6d9b726439dc6c" + "735cbb8fda5061051e5f2012f7960919de7a4e7e4b8c53aa39584ae1df649e33a951e6e1c5089aa251", - HksUsageSpec usageSpec = { + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_009_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = - "3d6968c44be17c9379d982a739429424e24c30dda87732d9858efd0ed43a43d2e5abad0bb2a84254700b6d2c3f41a7fb6d9b726439dc6c" - "735cbb8fda5061051e5f2012f7960919de7a4e7e4b8c53aa39584ae1df649e33a951e6e1c5089aa251"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaDecrypt_009 - * @tc.name : HksCryptoHalRsaDecrypt_009 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_009, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000040000800000008000000080000000bc294482ddb7abe39a04a31b8410e9115691e8cdedc7aa060a63977d55a6f924f8387d" "93bba101ad7351ad244baf25d19a840dc975409801fe634a603cce8fec3f2c40db3d2b6f0053e4ae0c073f5d21c9632e4d3a61f4afac89" "5367e58eb6fc9a723e75f14a8dcd7dd210644427d9d26da3cb88aa085e9d3fb74bdeb16d4d250000000000000000000000000000000000" @@ -645,169 +320,133 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_009, Function | SmallTes "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" "014fc97801be1eba46a2f2c06f548b0f2988fa0a2bf85e281cb39f1387d4201f99ab9fd8b02269dd9a3d422f172af8b422b350b7bfeb76" "5e7ec9ee3485a68338c78cc6cd9ceb514aa6b7cce5811306d6d256b3a1d6f6e1a2c309b0d721a0a32566c8e030794c90d984af31685a99" - "70960dc0698a51f3e03211fa43b3a4f9336141"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_PKCS1_V1_5, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "29bbe6754eba61b5b2907a73f03d4c3d21ec3b15296f78cc12bc870eaea302e2f1f0703c53d9a8ead057079affc" + "70960dc0698a51f3e03211fa43b3a4f9336141", + .hexData = "29bbe6754eba61b5b2907a73f03d4c3d21ec3b15296f78cc12bc870eaea302e2f1f0703c53d9a8ead057079affc" "0e1bf7b740593f826f8b2e78c7f580bb311c04bae6005576a0df747c7353b827719ba551fdbc40209733b2b4049" - "de1fbae809ff6d548b53338bb9259699caed4281e2a5f10ae9247436ef9b892ba2d4be4fd7"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaDecrypt_010 - * @tc.name : HksCryptoHalRsaDecrypt_010 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_010, Function | SmallTest | Level1) -{ - int32_t ret; + "de1fbae809ff6d548b53338bb9259699caed4281e2a5f10ae9247436ef9b892ba2d4be4fd7", - uint32_t keyLen = strlen(RSA_2048_PKCS1PADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_PKCS1PADDING_KEY[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_010_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000080000000100000001000000010000ddf3e9c6589658e5c124a49d473db529e8eb08b99c351cf7c5d502f64def9752d4ee88" + "d942cbdbc7fb46eac9d9b9f9b309fbffa99c9fe05363b2d5e71c2d132bc83d74f0b8441266fc2f6f0462b54fa0ffaef92bb93cec2d1805" + "9db40ff9d579f7980c08cb9a30d076d6ebf50f4166514bd00cdf20ca042ddf13581feddd32b15e8508f2b185f4e6c77217c5096a9dfecd" + "5132ee4ce41bccd3faa75abcf1014e5e27328d3a1b08e56c33d5f5f2fe8b8f232db6953a337bca29e2726165732c8d1aae10a6e9c60ce5" + "4b2423868e6d024dfdfab45fbb3d589d06fb8f55564bdc2bb07c1c84cf8c076045706b36e6715c4dc8cd1f4fe751de77b031b5bcf7cde7" + "41000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000001000151ac53b5fd1b361335837a5fb5bb6b52c4b6" + "d83b14d42698b65faffb5aaa7390b37223416f66fcb5162dfe6fd082b2f3c314cbfb69fb1add14aed62f791acd172b54121812765a1f33" + "657100b821e7ef62a6cc61de842094676689a59ccb5e56c75957f45497a4a6d1543cf7ac69707131e89913f248e448ccf19d58027b870f" + "361c57bc60e75da62e75d94b7e42c544e7ef183fd1935f0ca8d637e18cc4acae0e99f8aabbf83c968460b5237eac3271f214fd10580166" + "c836e067948438f8a3c5edded4871baf6acab762e501db5fde6f2ec201072532c109d0a55cdf0e275322ccf326c9a2a6b235d5742067b6" + "f7912bf772c9039385ab0a81c0186bf91001", + .hexData = "ab325c28d67e141d0af060d14d6f51858b7ef237756d41fb26d3ee4d64992fe2dc47028a7295da19b751fe3023399ac2b6fc368b479735" "e24812ac24e4c35831d556718378b502832ad8aff79eaf1790fbf2f173f6eea2f330fcc3b6463737a63c443ab9ced5f4bd0d07bd230579" "27c14d45cef42b7f4c73e92d61ba4006974259c6b47d236ed7076267f8d02204d793b89f360bb890578392ce23baed87998c1f7db074cf" "4a781ee4f7d273f44b67e541d1b79f50ed9be0315c64cfd6636e07fc02285435b765d612fa6d608a3e29f2c943ae2e13823021439c4b5a" - "647f8db556b41d3590983fea6dbb05ca140ce16ccf209978050ff670ecb0c1227b04820e"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + "647f8db556b41d3590983fea6dbb05ca140ce16ccf209978050ff670ecb0c1227b04820e", - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} + .decryptResult = HKS_SUCCESS, +}; -/** - * @tc.number : HksCryptoHalRsaDecrypt_011 - * @tc.name : HksCryptoHalRsaDecrypt_011 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_011, Function | SmallTest | Level1) -{ - int32_t ret; - - uint32_t keyLen = strlen(RSA_3072_PKCS1PADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_PKCS1PADDING_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_011_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "01000000000c0000800100008001000080010000b6267a0a854bc91d6a7f469ea9212dc3fb2a5a2e6626ec1f41e3f6436361b0c8141bcc" + "77e3e568dfee0068e0c863681ba0383b22046e6ef166274cbe19893e8a0ad4fdf86475998b0b00af04ccb0d1e1b42f89a20f56dccbfe14" + "45e794a8123434a252eab9e386a35d663669d219b34ad92f7a64a90a91f25ffa002ccc589843fde8cb3111d566b4a665c51d801f290ceb" + "be980ae71fad125e851c426d240fa361414c34a037d2a0840a25e4af4355931a6efc7c9faf11a5e8d225387965ea51f81f910786b9dfa9" + "8459678db6a0670b14b64a2be05ebd2db0f25fcab225f719b5cd97a0f38c490d38a710d594d50ba75ab0ebc04456fe12514f96351cdc9a" + "8a868389c932b3572726ce2303ab1e7f85c43c18e52ae14efcad4e0f65bffbf3254e10ad616ce169594373dcf1d44016c4fd77023bb0a8" + "302ce72de9ce1aba9d885c05aefa935492592afaae543c8c99e997dff2c1125a3931f5897b5ce2c6217d69be0d74612dea66347c076c44" + "5849c786e36a0c285e0f3b838d630b3347a96b000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100013f242b5e0642f51e6b525f6a947a59e0fbe9fc84e5084d05b0d393045d28fa1d014b799f7d" + "b2829e4d647af6a0c044d07ec3bf4bd5796a9fe7a76be4e1f93f629ecaa2973e4bbdc40336637528778ae9d08a420d997fa4de59df3134" + "4bc5cf39a59d375d02bf2a66eaf3899d39258b8f40a642a92e27e9dbb905729614e80930588e20118c7b0b35481133393cb69086581a23" + "9e73ebf914cb0b1d76b15ab4c90fe790c1156104747c11007dbb7b7de8965b2ecf0c93a56c7bbe8d047ca0a58edaa75649497e7a4c1b69" + "90a9d6fda6dcbf9732d517a01a3818287c8717949fa4820d88f3a5918bc0d629d88ae63e1b9ba0a52bd8cefdf30e4b273e9ead163dad87" + "bafb456b7af8b8e5dc353eda84195190b994e447758f082c1d9700d83655f1956f1c75dd5cde9880169b7f7720cc39761411a3c98cb25d" + "ce939c5c1724c07f31a1bfb59771d06cee3c6057e04489ceec6a122866d67d19923c7c5cbf598e48ab4fede639807b9d3d6f83aa821411" + "94019bc2c4fd028ccca7dc4e56e657f931", + .hexData = "06f006e44c76a83944663b77495304ed3cdbe478aa2132eaa1fcdf0b690a791b240ca9f4771a901c9ac5f1fedb9547260d20037e339331" "21f99b022c465f9fcea0c3b5789c79c57d5ae884104a914cf7f0d44aa37e5602d029b6c7ad3c714fce96b229eed0aa51aedf7c79351ec6" "9025cf32ea4d32f7e04b59530a4241cf823bf7a9cb1e6ce877970b0bcd016b1db78d82c8ab53c114177d5ee184cd193d59244a6e575353" "9f25e7058b1deb48c0af84ae2402cef58c454575eb07c5be0516881c0699d7870a00d8d0acb6fc8775bed70be9ca0d040ff82017e22ffd" "38571988659480cc29a41163940d7fa74f57dac386a55334d4cc7be312f499cb55c19389f92bbe2b7200ef1218323efe2793981695e527" "3253ac14139b9dcd27c2c216b7a284fab2b7f4fb91ec97bf9974b214af1f718efd2973af9cc1ce4349614e6131b1c39a5e6be4b273a268" - "4c706f054c87a4afc64c1f80293143772e010482b61dd028612d1935d7c372bf6236a4863faef090fe10597bf91fe2464bb60b0c18e2"; - uint32_t dataLen = strlen(hexData) / 2; + "4c706f054c87a4afc64c1f80293143772e010482b61dd028612d1935d7c372bf6236a4863faef090fe10597bf91fe2464bb60b0c18e2", - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; + .decryptResult = HKS_SUCCESS, +}; - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaDecrypt_012 - * @tc.name : HksCryptoHalRsaDecrypt_012 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_012, Function | SmallTest | Level1) -{ - int32_t ret; - - uint32_t keyLen = strlen(RSA_4096_PKCS1PADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_PKCS1PADDING_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_DECRYPT_012_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000100000000200000002000000020000c214a594a87457faccdfa9e466160af3a292f93003783fa46feeae2d84c0c41704d01a" + "2eb9874b59fcd217d7394e01e20a9fd162ef4de6c87adc11d423bc13c1f2b609e73c5ff20251a7e9e940fdb2fed3e8d04a2dc5fd33708e" + "aeea6b85ea021487daa0d8cc52b1ee0299915a5dc5b469792908aa05bad12d4c1af13c5ab552849c480ac6bec9fd4256d2b2b8f4f48583" + "f471c8f9e3c099c170e4863f5935ae11475d45bf4a1c5022937c31cdb23379f3bdbbfc8f59cce6dff3b02f201f660640605c9cf9f489da" + "74d378f9a97cc1284662346fd78f621c7b36b15b60cc5d645b5217a5aaee9f4c5f0cd1a3ba6d4fcfc49e472951e300af124106f38fc10f" + "3e40812997b93c35e44e8267e5d88bb0fba1e941801ee360317d1b4be71e40332d2a44c8727f7ae36eefe83906b4bc44214f126882f03a" + "9856e08268784c39fa351a7a00fbe916c2279ca679d7fa39a386e7ad50a08511031a480ffb449928b8e6b729921671f882f85dffbea3b6" + "93c362c311cba5ab909f06c7e2e333d11ca9ed0a821f4029101788071471236bd7af5a6e84ee6f5b7010a35ecd4abc894db5e5283322e7" + "5ef6f539d8a1524f155a7d2da825f42b11b80358d806d28934ef73014e863eeca74156d4b1b066ae11a875b746164095ed815b10478a37" + "cae6fa96fe16e9833397270fd531f7c1a9cfae0caad254e3b659e37e3fa9a1dcf07b48e101000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100012f" + "99f4cab34e65cdc3b60feb4f0695051098cfb971006b4b9f9080f3f51d7a7ad2d95fb29a1a8ee6b155ae37417cda856069b667779e39be" + "6e33cfc3a2481ce872e92720a9f4365d4f3dc9e745e373a580c017663a37d7546884f66dd49571c1b4db654a12227b1ddcec9251ce4235" + "9d7c49154164c22701eb04418f6d682a14e525979ddd052a718d75d213b7bd8cc3ba8b97e4dd357925bd063d6697deff85840366e31679" + "ccdbf2bf0db5016875abb19695a6ea59f221a64814ac5a4a99316b54b722614413139b97ca922179d1be5914f91b7d59538cfcc37b5898" + "3347acb7a138df8f3f1b9f15a9053a0d1d8677c517b508736723e1ccae5a501eb011569bd1d1dc71f75681c5871497a149bdd4c0cfe7ca" + "acca439faba11526aee5f280345555c81f09213e6d6699511cece3dcb1ef47694c3d2eada01653d565dd0f85a56b9bf35ed63f1dcffdec" + "73939a2bd962f67feb49aeca0395214d7d2430b6a9c43a93f49386ee99579a46ad9848138ca08c0c02c4036f538f41b708bd1ce3be00c6" + "4caff64bfbeafe65d19b245f3547b999d84163e51c200b91b762728e43d5eace6ebec90119be092ae6f131ea7b5d5901eda3b8cbca01f0" + "df7f98dc3aab37712c3b223d03510ce241cb81e5719fb8ee161a1346d8323397d2ab673695d5d08816f1c0fc61073eb33471d29d7ecdcd" + "083678709efd4b63e5f0a699ec19e949", + .hexData = "2769734972944c17d96fadc2c2ac2295a0b0fbbeec6bbc866ec2f4b49af477de0be17ce35d5568780ec74400dfccc7dfcd53a5ce84c758" "02bb3e20e66dfd2e9f35df0e94efab95e5e946bd203865abebd8280f0ec2a072e307a40ef7828d0c5c9149a1c292bbf25f1e5682e78a1c" "f13301b830131c487463d04def399b5d04add2c145293c5903424bdbca2ae7c7010383e81c7b1371bbcd481e19a4234074fcd1d369de0d" @@ -817,23 +456,160 @@ HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_012, Function | SmallTes "9748400c97e169bc1aee1833f628e37c42ed840d2845fd5dc7217316eb7225ac64b6b97a487448f3aa2a5b2d3a9a484bd0aa9eaef58e00" "04b83610089129f8d7a66507643a5d99a5188e2bd0bdf2caa1b0b93d198401f5ca2859b5286a351e41fa1ebefc64d0213e957387cbd8f6" "8fce198134a27a3ee691efdd9ac83eb870ade586b28f9ca9e2758c21cd8d2fa18a8316e78bdf0cbe9de48416beb60be675662429e7ef0d" - "4ee157e6fd03dc292c7d4cc39b6cef7b09"; - uint32_t dataLen = strlen(hexData) / 2; + "4ee157e6fd03dc292c7d4cc39b6cef7b09", - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; + .decryptResult = HKS_SUCCESS, +}; +} // namespace - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); +class HksCryptoHalRsaDecrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + + EXPECT_EQ( + HksCryptoHalDecrypt(&key, &testCaseParams.usageSpec, &message, &cipherText), testCaseParams.decryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); } +}; + +/** + * @tc.number : HksCryptoHalRsaDecrypt_001 + * @tc.name : HksCryptoHalRsaDecrypt_001 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_001_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_002 + * @tc.name : HksCryptoHalRsaDecrypt_002 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_002_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_003 + * @tc.name : HksCryptoHalRsaDecrypt_003 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_003, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_003_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_004 + * @tc.name : HksCryptoHalRsaDecrypt_004 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_004_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_005 + * @tc.name : HksCryptoHalRsaDecrypt_005 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_005_PARAMS); +} - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; +/** + * @tc.number : HksCryptoHalRsaDecrypt_006 + * @tc.name : HksCryptoHalRsaDecrypt_006 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_006, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_006_PARAMS); +} - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); +/** + * @tc.number : HksCryptoHalRsaDecrypt_007 + * @tc.name : HksCryptoHalRsaDecrypt_007 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_007, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_007_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_008 + * @tc.name : HksCryptoHalRsaDecrypt_008 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_008, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_008_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_009 + * @tc.name : HksCryptoHalRsaDecrypt_009 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_009, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_009_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_010 + * @tc.name : HksCryptoHalRsaDecrypt_010 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_010, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_010_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_011 + * @tc.name : HksCryptoHalRsaDecrypt_011 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_011, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_011_PARAMS); +} + +/** + * @tc.number : HksCryptoHalRsaDecrypt_012 + * @tc.name : HksCryptoHalRsaDecrypt_012 + * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaDecrypt, HksCryptoHalRsaDecrypt_012, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_DECRYPT_012_PARAMS); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp index 8209b663..56a6b42d 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_encrypt.cpp @@ -22,466 +22,232 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -namespace { -const char RSA_1024_NOPADDING_KEY[] = - "0100000000040000800000008000000080000000a51514cb129c6e19e50eaf764e08067e5720ba300a9031a5a40509d210b0e5a072b7dc" - "6e0b9da82b59bb5c41b0baabbd4b534eb6a8fd50c25a7d9b7b1c7d9e808c5de65a0658fbb353b635dce78ab6d09478257b7e8b5b508cd7" - "5a735ca3944aba2bc8f443cd9ed6b0096cfda268e2fda1462182b313b25f27ecdc4510fc87770000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" - "016671c4ab98eb16b05f2353e3d8dcc61ad53aec10301df791514e0720235783c8a4285154c1449f3df7bb7baf105b67845b2061b29d00" - "4683b5e049028755b56c15879f4b5dc76e57fd0296c1286b347f7387b2f9e8cee0fbd6cf034cd16dffa6cc2f5c1101c1f430c265ea0d5b" - "c27a01672405d4f670baf194ccb4ba87a3c5b1"; -const char RSA_2048_NOPADDING_KEY[] = - "0100000000080000000100000001000000010000a0286e22fea334e1ec2f48a955d91d44992e2fda06d23ff00bbfdd70f0f961bed02781" - "e345ad866f63c217ae82f84db6f3ef2d5937fe9684f2c1e1ac091e81eb7dc1da7bb4a2ad7e3bb2911cfbfa8c0244527b91259b5b7ac1e4" - "32701ac4e5c87186b59340ae0b67e4d2805ad01431121d907181aaac1d7a26e4703b1812c711fa3d056a8f4709a923193895f2657e66b0" - "b109dbc65c9703bc08d79696f35f63e790aff9cf4323320288d5bc9360f08dc9576d7cba0792bc56864a844b72c49041340b8b3487dba1" - "f724bac429e7d40c99d752d4be9cca352b59a7594ddae02784c3b8e137f141e2a77e098524aec3b96d989fe09e28578fabeb6e6976bba3" - "77000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000100010490024b36ebd956d24eaa88406cd5fb9d4d" - "868974864ad200d3af70473d237eb7195906eb763d0d314f57335e81ca5cfae80667b343aa7011265ad276d40aa975c4aeffb52ea9389e" - "64c0e38d7e1ebcf5cb4fbfdbcd6836c00d4b2e8c64ad931f40d22d66bb4e91e01feb0e2b3d580487191552b754fde5fbf3a80ad6edba04" - "0a8d0c30fa413ce7cb7d1bdd5960cb6d9c68285cf7ca8abde4c2a5aa2f7ef875e66094b9a263e529f38651f405ee9410ae45f3f272effb" - "d318c23eb112bb295b79cfff9f5df4ed2a91c590c03fdb304e74dd7758916b91e4716a6b4f5703516aaad8a8cb9f2b603f11ac90b0e941" - "ffdf7059c7ba1a74c5bf6435a8040f175ae1"; -const char RSA_3072_NOPADDING_KEY[] = - "01000000000c0000800100008001000080010000b3c325e9339d6cc17db61da704dc05364320f4ca208467ddbf3d44a625a5dc3a6cd134" - "27cce14a3f0a2f7a50a6e377b52f73bb824254d8bed785b91303f30211c20d1bef9ddd5e4ee88b7425ef2846f41e791d5a9670682553be" - "ce2dbf41d88abbfde7dc3f450572290daabb55a1a56b28b282de9576249de95d0075d47914943f52d9a559ddcec9b5f610eeee9bf10cd3" - "d807d00abdf94e7f63a50d01ddb8cff95e0452e56e614115031fe5ddb91d46c13358c1f42685fc19e09a2cf3170fa0bf0e0a380400fc8c" - "c3e2f287c68d48ae04ecd3448273198744f37187eee774cc2dcc28fd3b037af7f4c54e30dd254c12b6f482c32e2de7014fb48f5badfea3" - "91531b6a58c1c95f84ded943cc8fe113ff21e3c5f5625d88c77ee24ecad6b22e0013831af764c2a87c7db71062b922c136402a102391c4" - "911bb286e8d96efa8e1c629d8818fd02de45bcdb8352cf16af7f282e5676a4b07c74a7e52b94726963fb79f433991114415474f90b10e3" - "fea5d24043ce964298a938aa79014ae98da4b3000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000010001546d4714ebc4f81b382b9c69a102a500032f2b48f354bc638d39fd4ffb4696d469df279bb9" - "c1e5d90db396c2e25edb0e21a73d5dc4418d3ab4867d91ccbd092fc5efda3b03edc029575687ca7934757e9a015024079beb8dfc7314ea" - "af75017ac7284d09483de67ce38323b8b0532719d9175e17a422c4b7d5ae7454e2e1ab24a54908277cb98c317860853b729d92ecef61fa" - "e95ee23281079b891d3ecf1fc9add8d63708c27ab2d2679147a8871494f290671350d3f7019c35bcb377c850f1e87dcc174873ecd98d0c" - "f6ed9dd83118142d9f9cef1301b221a047440609ac3be88bf69e8e50843f75c855f974dc00e18168c8000a9a4ca65247560a5187ffed04" - "4eb4da9e4e517870ab2dcbf6574c63676f8a3620852940c6b185186d21a53bdb20e7bf7d16288a3d9e0d47844d2b605f8ba879e87ce348" - "033667577d6c91645f30f2720e9f9229ccc7a270215b124677650e94e5c181cdac04e2b2dfb8c3165f3a4a556c78684f60e602fb79f911" - "68a938c5f0c4254265ae72f54938268021"; -const char RSA_4096_NOPADDING_KEY[] = - "0100000000100000000200000002000000020000e5a087382ce37175f66f6e4ebc00c0cb7d9b0486425eed1bf831cb43566031894221a1" - "f1b0c7275318d82b186640256c3f1325f32a740e2c9ab3f7ca866d02b982f9caaa59eb49d7e3268f6b902e589ec65c91164d1e370ec407" - "b06f9687b059835574ce9a541607b08e18a33fc74ec9ae0bb7e2a3c1fd73eeffb493e2e939b9ab7501dd0692ac63d262cb4130fae6be54" - "42964a80f3e7474c0fee48dce2940e7fae7a8a8aec30a8d71dab54b1d42b1a364fc60a837f2533ca79dec02796cc00202db34dfb674641" - "d20aa00c1d748aae18f5219ff5232a479e4e61a653c54b84ec1fbbd16624d595af1bb831508af96f02494312e46bcccca9e8c6f471c082" - "c7a2e742a239cb908279b63f29385d53172ece4a85272acca9e52b9599c244a6ee786b7ddb599c198362bd5697c522f667457c11503286" - "4e4364325873652f9e69b27aae8b1c8c385164c8edcdf401dc306ade1907449bd1c58593681b5f8e8cb536c9e60390152ce648ada0f091" - "d3b11ca660f44421257434b69f4f60a6159cb86c8911559319e765550d142d58e844896259f0e8eb471a2150a79221c31d0b2032b3d716" - "b3c00255eb300fbb2fba4bec0d4041d7b010939fd339e8080d52c7ded936af229358a580ac87518bbd785fb103534b9ad3f19501125b5a" - "9467d4b76e5e571d2b1393454e92711be52d1f9482f7997f4e65102995874febc087792b77000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000198" - "f34d3e40c01ac22d2cd9f7bdc86ea2dc7e560c2bc758fe695a997eb7d90905d933d7cfca254d6f4f3c25b071e3464a0cd56f50c2355d7f" - "9e6843a3f5d8449956c19599d49d21a9985705eeeab1c43bb5fad0755f56c1eba6ed4c3b77b3d7e637d1c3251eace5a3a7996e95c694b6" - "4926120e20fb5ceababf36398ccbf6f78951c8753e48f387ba51d796754cefc2a482317c341222e4299c637c1fb269859f06b32c527de8" - "871cdf7496bbaa5b9d7e2f3101c3dd04e2bdd59f499d0a81aa4e6720a9af46c6ea884b24e2a84f3262714694791a37c97d8f08c642caec" - "3f9d66e374dbc0c5ddc11a9bf1c5c5ab557681d7aefeeb6594dc6c72bc67514937a6a399d80094486382538c330569a3a944375751d9eb" - "ed82c39bf81cf27f88c211070960d781719fb64d3c7a507c955e015cd3c4e968fea4d999d57245b30bcffae2c44ab6bfe4d2c3d7457a68" - "3f0580cdc0d4910e071ef624888db604f110eb6aa2a454cd9b74d4b9b857994452c092c20df2a0110ed81c8275aa745971e900c9485f67" - "82fbf666215762f2f971e4d213be05cb1760e4c7bfc3fb17ae1409039568ba3d9e2d34e282cc43c9db4ed8286a0a504022cbd23cd68cc7" - "94685dd6daddf1054673cb9b517495e0c39569e0627e4b8ef80bb196f58f53627af0a4142fb2b469cc767a348ce74ea8dbdc647386e485" - "62a124488021988f9d71ff68f2028a19"; -const char RSA_3072_PKCS1PADDING_KEY[] = - "01000000000c0000800100008001000080010000b6267a0a854bc91d6a7f469ea9212dc3fb2a5a2e6626ec1f41e3f6436361b0c8141bcc" - "77e3e568dfee0068e0c863681ba0383b22046e6ef166274cbe19893e8a0ad4fdf86475998b0b00af04ccb0d1e1b42f89a20f56dccbfe14" - "45e794a8123434a252eab9e386a35d663669d219b34ad92f7a64a90a91f25ffa002ccc589843fde8cb3111d566b4a665c51d801f290ceb" - "be980ae71fad125e851c426d240fa361414c34a037d2a0840a25e4af4355931a6efc7c9faf11a5e8d225387965ea51f81f910786b9dfa9" - "8459678db6a0670b14b64a2be05ebd2db0f25fcab225f719b5cd97a0f38c490d38a710d594d50ba75ab0ebc04456fe12514f96351cdc9a" - "8a868389c932b3572726ce2303ab1e7f85c43c18e52ae14efcad4e0f65bffbf3254e10ad616ce169594373dcf1d44016c4fd77023bb0a8" - "302ce72de9ce1aba9d885c05aefa935492592afaae543c8c99e997dff2c1125a3931f5897b5ce2c6217d69be0d74612dea66347c076c44" - "5849c786e36a0c285e0f3b838d630b3347a96b000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000100013f242b5e0642f51e6b525f6a947a59e0fbe9fc84e5084d05b0d393045d28fa1d014b799f7d" - "b2829e4d647af6a0c044d07ec3bf4bd5796a9fe7a76be4e1f93f629ecaa2973e4bbdc40336637528778ae9d08a420d997fa4de59df3134" - "4bc5cf39a59d375d02bf2a66eaf3899d39258b8f40a642a92e27e9dbb905729614e80930588e20118c7b0b35481133393cb69086581a23" - "9e73ebf914cb0b1d76b15ab4c90fe790c1156104747c11007dbb7b7de8965b2ecf0c93a56c7bbe8d047ca0a58edaa75649497e7a4c1b69" - "90a9d6fda6dcbf9732d517a01a3818287c8717949fa4820d88f3a5918bc0d629d88ae63e1b9ba0a52bd8cefdf30e4b273e9ead163dad87" - "bafb456b7af8b8e5dc353eda84195190b994e447758f082c1d9700d83655f1956f1c75dd5cde9880169b7f7720cc39761411a3c98cb25d" - "ce939c5c1724c07f31a1bfb59771d06cee3c6057e04489ceec6a122866d67d19923c7c5cbf598e48ab4fede639807b9d3d6f83aa821411" - "94019bc2c4fd028ccca7dc4e56e657f931"; -const char RSA_4096_PKCS1PADDING_KEY[] = - "0100000000100000000200000002000000020000c214a594a87457faccdfa9e466160af3a292f93003783fa46feeae2d84c0c41704d01a" - "2eb9874b59fcd217d7394e01e20a9fd162ef4de6c87adc11d423bc13c1f2b609e73c5ff20251a7e9e940fdb2fed3e8d04a2dc5fd33708e" - "aeea6b85ea021487daa0d8cc52b1ee0299915a5dc5b469792908aa05bad12d4c1af13c5ab552849c480ac6bec9fd4256d2b2b8f4f48583" - "f471c8f9e3c099c170e4863f5935ae11475d45bf4a1c5022937c31cdb23379f3bdbbfc8f59cce6dff3b02f201f660640605c9cf9f489da" - "74d378f9a97cc1284662346fd78f621c7b36b15b60cc5d645b5217a5aaee9f4c5f0cd1a3ba6d4fcfc49e472951e300af124106f38fc10f" - "3e40812997b93c35e44e8267e5d88bb0fba1e941801ee360317d1b4be71e40332d2a44c8727f7ae36eefe83906b4bc44214f126882f03a" - "9856e08268784c39fa351a7a00fbe916c2279ca679d7fa39a386e7ad50a08511031a480ffb449928b8e6b729921671f882f85dffbea3b6" - "93c362c311cba5ab909f06c7e2e333d11ca9ed0a821f4029101788071471236bd7af5a6e84ee6f5b7010a35ecd4abc894db5e5283322e7" - "5ef6f539d8a1524f155a7d2da825f42b11b80358d806d28934ef73014e863eeca74156d4b1b066ae11a875b746164095ed815b10478a37" - "cae6fa96fe16e9833397270fd531f7c1a9cfae0caad254e3b659e37e3fa9a1dcf07b48e101000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100012f" - "99f4cab34e65cdc3b60feb4f0695051098cfb971006b4b9f9080f3f51d7a7ad2d95fb29a1a8ee6b155ae37417cda856069b667779e39be" - "6e33cfc3a2481ce872e92720a9f4365d4f3dc9e745e373a580c017663a37d7546884f66dd49571c1b4db654a12227b1ddcec9251ce4235" - "9d7c49154164c22701eb04418f6d682a14e525979ddd052a718d75d213b7bd8cc3ba8b97e4dd357925bd063d6697deff85840366e31679" - "ccdbf2bf0db5016875abb19695a6ea59f221a64814ac5a4a99316b54b722614413139b97ca922179d1be5914f91b7d59538cfcc37b5898" - "3347acb7a138df8f3f1b9f15a9053a0d1d8677c517b508736723e1ccae5a501eb011569bd1d1dc71f75681c5871497a149bdd4c0cfe7ca" - "acca439faba11526aee5f280345555c81f09213e6d6699511cece3dcb1ef47694c3d2eada01653d565dd0f85a56b9bf35ed63f1dcffdec" - "73939a2bd962f67feb49aeca0395214d7d2430b6a9c43a93f49386ee99579a46ad9848138ca08c0c02c4036f538f41b708bd1ce3be00c6" - "4caff64bfbeafe65d19b245f3547b999d84163e51c200b91b762728e43d5eace6ebec90119be092ae6f131ea7b5d5901eda3b8cbca01f0" - "df7f98dc3aab37712c3b223d03510ce241cb81e5719fb8ee161a1346d8323397d2ab673695d5d08816f1c0fc61073eb33471d29d7ecdcd" - "083678709efd4b63e5f0a699ec19e949"; -} // namespace -class HksCryptoHalRsaEncrypt : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; + HksKeySize keySize; -/** - * @tc.number : HksCryptoHalRsaEncrypt_001 - * @tc.name : HksCryptoHalRsaEncrypt_001 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_001, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = - "0100000000020000400000004000000040000000ba5395c32972cdd04061fc45ac6d501555110a32300d44f57d6d7d9b478888361d815b" - "45c30aedce3674cf440c455552ba05ea9ef4659f37077c9498541f79d10000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000010001355e09702ba801411b9fb514f3ad1f99ec" - "9283dc1a1d42da1981c9cf36eee92c3154e0b65cd6653c01a0568dec5f969bf6581ca2aa3c572138cfc9a0b2b3535d"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + HksErrorCode encryptResult; +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_001_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" - "0000000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); + }, + .keyData = + "0100000000020000400000004000000040000000ba5395c32972cdd04061fc45ac6d501555110a32300d44f57d6d7d9b478888361d815b" + "45c30aedce3674cf440c455552ba05ea9ef4659f37077c9498541f79d10000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000010001355e09702ba801411b9fb514f3ad1f99ec" + "9283dc1a1d42da1981c9cf36eee92c3154e0b65cd6653c01a0568dec5f969bf6581ca2aa3c572138cfc9a0b2b3535d", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" + "0000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_512, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaEncrypt_002 - * @tc.name : HksCryptoHalRsaEncrypt_002 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-768-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_002, Function | SmallTest | Level1) -{ - int32_t ret; +}; - const char *keyData = - "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" - "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" - "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" - "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" - "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_002_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" + "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" + "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" + "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_768, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaEncrypt_003 - * @tc.name : HksCryptoHalRsaEncrypt_003 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-1024-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_003, Function | SmallTest | Level1) -{ - int32_t ret; +}; - uint32_t keyLen = strlen(RSA_1024_NOPADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_1024_NOPADDING_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_003_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); + }, + .keyData = + "0100000000040000800000008000000080000000a51514cb129c6e19e50eaf764e08067e5720ba300a9031a5a40509d210b0e5a072b7dc" + "6e0b9da82b59bb5c41b0baabbd4b534eb6a8fd50c25a7d9b7b1c7d9e808c5de65a0658fbb353b635dce78ab6d09478257b7e8b5b508cd7" + "5a735ca3944aba2bc8f443cd9ed6b0096cfda268e2fda1462182b313b25f27ecdc4510fc87770000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + "016671c4ab98eb16b05f2353e3d8dcc61ad53aec10301df791514e0720235783c8a4285154c1449f3df7bb7baf105b67845b2061b29d00" + "4683b5e049028755b56c15879f4b5dc76e57fd0296c1286b347f7387b2f9e8cee0fbd6cf034cd16dffa6cc2f5c1101c1f430c265ea0d5b" + "c27a01672405d4f670baf194ccb4ba87a3c5b1", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_1024, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaEncrypt_004 - * @tc.name : HksCryptoHalRsaEncrypt_004 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-2048-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_004, Function | SmallTest | Level1) -{ - int32_t ret; - - uint32_t keyLen = strlen(RSA_2048_NOPADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_NOPADDING_KEY[2 * ii]); - } +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_004_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000080000000100000001000000010000a0286e22fea334e1ec2f48a955d91d44992e2fda06d23ff00bbfdd70f0f961bed02781" + "e345ad866f63c217ae82f84db6f3ef2d5937fe9684f2c1e1ac091e81eb7dc1da7bb4a2ad7e3bb2911cfbfa8c0244527b91259b5b7ac1e4" + "32701ac4e5c87186b59340ae0b67e4d2805ad01431121d907181aaac1d7a26e4703b1812c711fa3d056a8f4709a923193895f2657e66b0" + "b109dbc65c9703bc08d79696f35f63e790aff9cf4323320288d5bc9360f08dc9576d7cba0792bc56864a844b72c49041340b8b3487dba1" + "f724bac429e7d40c99d752d4be9cca352b59a7594ddae02784c3b8e137f141e2a77e098524aec3b96d989fe09e28578fabeb6e6976bba3" + "77000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100010490024b36ebd956d24eaa88406cd5fb9d4d" + "868974864ad200d3af70473d237eb7195906eb763d0d314f57335e81ca5cfae80667b343aa7011265ad276d40aa975c4aeffb52ea9389e" + "64c0e38d7e1ebcf5cb4fbfdbcd6836c00d4b2e8c64ad931f40d22d66bb4e91e01feb0e2b3d580487191552b754fde5fbf3a80ad6edba04" + "0a8d0c30fa413ce7cb7d1bdd5960cb6d9c68285cf7ca8abde4c2a5aa2f7ef875e66094b9a263e529f38651f405ee9410ae45f3f272effb" + "d318c23eb112bb295b79cfff9f5df4ed2a91c590c03fdb304e74dd7758916b91e4716a6b4f5703516aaad8a8cb9f2b603f11ac90b0e941" + "ffdf7059c7ba1a74c5bf6435a8040f175ae1", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); + "000000000000000000000000000000000000000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_2048, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaEncrypt_005 - * @tc.name : HksCryptoHalRsaEncrypt_005 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-3072-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_005, Function | SmallTest | Level1) -{ - int32_t ret; +}; - uint32_t keyLen = strlen(RSA_3072_NOPADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_NOPADDING_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_005_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "01000000000c0000800100008001000080010000b3c325e9339d6cc17db61da704dc05364320f4ca208467ddbf3d44a625a5dc3a6cd134" + "27cce14a3f0a2f7a50a6e377b52f73bb824254d8bed785b91303f30211c20d1bef9ddd5e4ee88b7425ef2846f41e791d5a9670682553be" + "ce2dbf41d88abbfde7dc3f450572290daabb55a1a56b28b282de9576249de95d0075d47914943f52d9a559ddcec9b5f610eeee9bf10cd3" + "d807d00abdf94e7f63a50d01ddb8cff95e0452e56e614115031fe5ddb91d46c13358c1f42685fc19e09a2cf3170fa0bf0e0a380400fc8c" + "c3e2f287c68d48ae04ecd3448273198744f37187eee774cc2dcc28fd3b037af7f4c54e30dd254c12b6f482c32e2de7014fb48f5badfea3" + "91531b6a58c1c95f84ded943cc8fe113ff21e3c5f5625d88c77ee24ecad6b22e0013831af764c2a87c7db71062b922c136402a102391c4" + "911bb286e8d96efa8e1c629d8818fd02de45bcdb8352cf16af7f282e5676a4b07c74a7e52b94726963fb79f433991114415474f90b10e3" + "fea5d24043ce964298a938aa79014ae98da4b3000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000010001546d4714ebc4f81b382b9c69a102a500032f2b48f354bc638d39fd4ffb4696d469df279bb9" + "c1e5d90db396c2e25edb0e21a73d5dc4418d3ab4867d91ccbd092fc5efda3b03edc029575687ca7934757e9a015024079beb8dfc7314ea" + "af75017ac7284d09483de67ce38323b8b0532719d9175e17a422c4b7d5ae7454e2e1ab24a54908277cb98c317860853b729d92ecef61fa" + "e95ee23281079b891d3ecf1fc9add8d63708c27ab2d2679147a8871494f290671350d3f7019c35bcb377c850f1e87dcc174873ecd98d0c" + "f6ed9dd83118142d9f9cef1301b221a047440609ac3be88bf69e8e50843f75c855f974dc00e18168c8000a9a4ca65247560a5187ffed04" + "4eb4da9e4e517870ab2dcbf6574c63676f8a3620852940c6b185186d21a53bdb20e7bf7d16288a3d9e0d47844d2b605f8ba879e87ce348" + "033667577d6c91645f30f2720e9f9229ccc7a270215b124677650e94e5c181cdac04e2b2dfb8c3165f3a4a556c78684f60e602fb79f911" + "68a938c5f0c4254265ae72f54938268021", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); + "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_3072, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksCryptoHalRsaEncrypt_006 - * @tc.name : HksCryptoHalRsaEncrypt_006 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-4096-NOPADDING key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_006, Function | SmallTest | Level1) -{ - int32_t ret; +}; - uint32_t keyLen = strlen(RSA_4096_NOPADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_NOPADDING_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_006_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_NONE, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000100000000200000002000000020000e5a087382ce37175f66f6e4ebc00c0cb7d9b0486425eed1bf831cb43566031894221a1" + "f1b0c7275318d82b186640256c3f1325f32a740e2c9ab3f7ca866d02b982f9caaa59eb49d7e3268f6b902e589ec65c91164d1e370ec407" + "b06f9687b059835574ce9a541607b08e18a33fc74ec9ae0bb7e2a3c1fd73eeffb493e2e939b9ab7501dd0692ac63d262cb4130fae6be54" + "42964a80f3e7474c0fee48dce2940e7fae7a8a8aec30a8d71dab54b1d42b1a364fc60a837f2533ca79dec02796cc00202db34dfb674641" + "d20aa00c1d748aae18f5219ff5232a479e4e61a653c54b84ec1fbbd16624d595af1bb831508af96f02494312e46bcccca9e8c6f471c082" + "c7a2e742a239cb908279b63f29385d53172ece4a85272acca9e52b9599c244a6ee786b7ddb599c198362bd5697c522f667457c11503286" + "4e4364325873652f9e69b27aae8b1c8c385164c8edcdf401dc306ade1907449bd1c58593681b5f8e8cb536c9e60390152ce648ada0f091" + "d3b11ca660f44421257434b69f4f60a6159cb86c8911559319e765550d142d58e844896259f0e8eb471a2150a79221c31d0b2032b3d716" + "b3c00255eb300fbb2fba4bec0d4041d7b010939fd339e8080d52c7ded936af229358a580ac87518bbd785fb103534b9ad3f19501125b5a" + "9467d4b76e5e571d2b1393454e92711be52d1f9482f7997f4e65102995874febc087792b77000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000198" + "f34d3e40c01ac22d2cd9f7bdc86ea2dc7e560c2bc758fe695a997eb7d90905d933d7cfca254d6f4f3c25b071e3464a0cd56f50c2355d7f" + "9e6843a3f5d8449956c19599d49d21a9985705eeeab1c43bb5fad0755f56c1eba6ed4c3b77b3d7e637d1c3251eace5a3a7996e95c694b6" + "4926120e20fb5ceababf36398ccbf6f78951c8753e48f387ba51d796754cefc2a482317c341222e4299c637c1fb269859f06b32c527de8" + "871cdf7496bbaa5b9d7e2f3101c3dd04e2bdd59f499d0a81aa4e6720a9af46c6ea884b24e2a84f3262714694791a37c97d8f08c642caec" + "3f9d66e374dbc0c5ddc11a9bf1c5c5ab557681d7aefeeb6594dc6c72bc67514937a6a399d80094486382538c330569a3a944375751d9eb" + "ed82c39bf81cf27f88c211070960d781719fb64d3c7a507c955e015cd3c4e968fea4d999d57245b30bcffae2c44ab6bfe4d2c3d7457a68" + "3f0580cdc0d4910e071ef624888db604f110eb6aa2a454cd9b74d4b9b857994452c092c20df2a0110ed81c8275aa745971e900c9485f67" + "82fbf666215762f2f971e4d213be05cb1760e4c7bfc3fb17ae1409039568ba3d9e2d34e282cc43c9db4ed8286a0a504022cbd23cd68cc7" + "94685dd6daddf1054673cb9b517495e0c39569e0627e4b8ef80bb196f58f53627af0a4142fb2b469cc767a348ce74ea8dbdc647386e485" + "62a124488021988f9d71ff68f2028a19", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff0000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" @@ -491,150 +257,69 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_006, Function | SmallTes "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; + "0000000000000000000000000000000000", + .keySize = HKS_RSA_KEY_SIZE_4096, - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); #if defined(_USE_OPENSSL_) - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} +}; -/** - * @tc.number : HksCryptoHalRsaEncrypt_007 - * @tc.name : HksCryptoHalRsaEncrypt_007 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_007, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_007_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "0100000000020000400000004000000040000000a6a29490a5a6b309192f7571daa7cacce05dc5a5af6e4c0648ffc3dd72704651c806ee" "0cb61afc2f118bb24075a2f303cc548bfd9fea2c3dc945d5d976457ae10000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000100012a295cb9b4901720a834afdc9cdc739d9e" - "ef5b00ef0053500bcc5afc7ee6158457279c58942bafa28d436be509cd30b841e40cb769efffe8723b70c6f464f599"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "ef5b00ef0053500bcc5afc7ee6158457279c58942bafa28d436be509cd30b841e40cb769efffe8723b70c6f464f599", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_512, + + .encryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_008_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_512); - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaEncrypt_008 - * @tc.name : HksCryptoHalRsaEncrypt_008 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-768-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_008, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000030000600000006000000060000000d056e8b387700c781feb01097ecd9868c32af0cea33292634b2b0027117b75af0ebdb9" "6172c776ef95bb7c3dcfa6126858e6fe69c87e0ed69dcf81e15ebef50f03fbaffaee527c291f3740e521730271eb3b63f4057cba780c6a" "c8520816d79300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001acbf7361f12a5a5c" "7c72bac069d105cfd00c59f1ace630f57e0d60aa0457ef63c10055a754a9c997acfaf170bb2dc3d21b8e26541ba01ff0b99788b13a553b" - "f97c8c71cd149dcb421fb96affc55a6588adb642251bd991ef7d54890950e5b719"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "f97c8c71cd149dcb421fb96affc55a6588adb642251bd991ef7d54890950e5b719", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_768, + + .encryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_009_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_768); - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaEncrypt_009 - * @tc.name : HksCryptoHalRsaEncrypt_009 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-1024-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_009, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000040000800000008000000080000000bc294482ddb7abe39a04a31b8410e9115691e8cdedc7aa060a63977d55a6f924f8387d" "93bba101ad7351ad244baf25d19a840dc975409801fe634a603cce8fec3f2c40db3d2b6f0053e4ae0c073f5d21c9632e4d3a61f4afac89" "5367e58eb6fc9a723e75f14a8dcd7dd210644427d9d26da3cb88aa085e9d3fb74bdeb16d4d250000000000000000000000000000000000" @@ -642,54 +327,23 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_009, Function | SmallTes "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" "014fc97801be1eba46a2f2c06f548b0f2988fa0a2bf85e281cb39f1387d4201f99ab9fd8b02269dd9a3d422f172af8b422b350b7bfeb76" "5e7ec9ee3485a68338c78cc6cd9ceb514aa6b7cce5811306d6d256b3a1d6f6e1a2c309b0d721a0a32566c8e030794c90d984af31685a99" - "70960dc0698a51f3e03211fa43b3a4f9336141"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "70960dc0698a51f3e03211fa43b3a4f9336141", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_1024, - HksUsageSpec usageSpec = { + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_010_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_1024); - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaEncrypt_010 - * @tc.name : HksCryptoHalRsaEncrypt_010 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-2048-PKCS1Padding key. - */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_010, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000080000000100000001000000010000ddf3e9c6589658e5c124a49d473db529e8eb08b99c351cf7c5d502f64def9752d4ee88" "d942cbdbc7fb46eac9d9b9f9b309fbffa99c9fe05363b2d5e71c2d132bc83d74f0b8441266fc2f6f0462b54fa0ffaef92bb93cec2d1805" "9db40ff9d579f7980c08cb9a30d076d6ebf50f4166514bd00cdf20ca042ddf13581feddd32b15e8508f2b185f4e6c77217c5096a9dfecd" @@ -704,88 +358,237 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_010, Function | SmallTes "657100b821e7ef62a6cc61de842094676689a59ccb5e56c75957f45497a4a6d1543cf7ac69707131e89913f248e448ccf19d58027b870f" "361c57bc60e75da62e75d94b7e42c544e7ef183fd1935f0ca8d637e18cc4acae0e99f8aabbf83c968460b5237eac3271f214fd10580166" "c836e067948438f8a3c5edded4871baf6acab762e501db5fde6f2ec201072532c109d0a55cdf0e275322ccf326c9a2a6b235d5742067b6" - "f7912bf772c9039385ab0a81c0186bf91001"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "f7912bf772c9039385ab0a81c0186bf91001", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_2048, - HksUsageSpec usageSpec = { + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_011_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_PKCS1_V1_5, .digest = HKS_DIGEST_NONE, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_2048); + }, + .keyData = + "01000000000c0000800100008001000080010000b6267a0a854bc91d6a7f469ea9212dc3fb2a5a2e6626ec1f41e3f6436361b0c8141bcc" + "77e3e568dfee0068e0c863681ba0383b22046e6ef166274cbe19893e8a0ad4fdf86475998b0b00af04ccb0d1e1b42f89a20f56dccbfe14" + "45e794a8123434a252eab9e386a35d663669d219b34ad92f7a64a90a91f25ffa002ccc589843fde8cb3111d566b4a665c51d801f290ceb" + "be980ae71fad125e851c426d240fa361414c34a037d2a0840a25e4af4355931a6efc7c9faf11a5e8d225387965ea51f81f910786b9dfa9" + "8459678db6a0670b14b64a2be05ebd2db0f25fcab225f719b5cd97a0f38c490d38a710d594d50ba75ab0ebc04456fe12514f96351cdc9a" + "8a868389c932b3572726ce2303ab1e7f85c43c18e52ae14efcad4e0f65bffbf3254e10ad616ce169594373dcf1d44016c4fd77023bb0a8" + "302ce72de9ce1aba9d885c05aefa935492592afaae543c8c99e997dff2c1125a3931f5897b5ce2c6217d69be0d74612dea66347c076c44" + "5849c786e36a0c285e0f3b838d630b3347a96b000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100013f242b5e0642f51e6b525f6a947a59e0fbe9fc84e5084d05b0d393045d28fa1d014b799f7d" + "b2829e4d647af6a0c044d07ec3bf4bd5796a9fe7a76be4e1f93f629ecaa2973e4bbdc40336637528778ae9d08a420d997fa4de59df3134" + "4bc5cf39a59d375d02bf2a66eaf3899d39258b8f40a642a92e27e9dbb905729614e80930588e20118c7b0b35481133393cb69086581a23" + "9e73ebf914cb0b1d76b15ab4c90fe790c1156104747c11007dbb7b7de8965b2ecf0c93a56c7bbe8d047ca0a58edaa75649497e7a4c1b69" + "90a9d6fda6dcbf9732d517a01a3818287c8717949fa4820d88f3a5918bc0d629d88ae63e1b9ba0a52bd8cefdf30e4b273e9ead163dad87" + "bafb456b7af8b8e5dc353eda84195190b994e447758f082c1d9700d83655f1956f1c75dd5cde9880169b7f7720cc39761411a3c98cb25d" + "ce939c5c1724c07f31a1bfb59771d06cee3c6057e04489ceec6a122866d67d19923c7c5cbf598e48ab4fede639807b9d3d6f83aa821411" + "94019bc2c4fd028ccca7dc4e56e657f931", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_3072, + + .encryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_ENCRYPT_012_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_PKCS1_V1_5, + .digest = HKS_DIGEST_NONE, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = + "0100000000100000000200000002000000020000c214a594a87457faccdfa9e466160af3a292f93003783fa46feeae2d84c0c41704d01a" + "2eb9874b59fcd217d7394e01e20a9fd162ef4de6c87adc11d423bc13c1f2b609e73c5ff20251a7e9e940fdb2fed3e8d04a2dc5fd33708e" + "aeea6b85ea021487daa0d8cc52b1ee0299915a5dc5b469792908aa05bad12d4c1af13c5ab552849c480ac6bec9fd4256d2b2b8f4f48583" + "f471c8f9e3c099c170e4863f5935ae11475d45bf4a1c5022937c31cdb23379f3bdbbfc8f59cce6dff3b02f201f660640605c9cf9f489da" + "74d378f9a97cc1284662346fd78f621c7b36b15b60cc5d645b5217a5aaee9f4c5f0cd1a3ba6d4fcfc49e472951e300af124106f38fc10f" + "3e40812997b93c35e44e8267e5d88bb0fba1e941801ee360317d1b4be71e40332d2a44c8727f7ae36eefe83906b4bc44214f126882f03a" + "9856e08268784c39fa351a7a00fbe916c2279ca679d7fa39a386e7ad50a08511031a480ffb449928b8e6b729921671f882f85dffbea3b6" + "93c362c311cba5ab909f06c7e2e333d11ca9ed0a821f4029101788071471236bd7af5a6e84ee6f5b7010a35ecd4abc894db5e5283322e7" + "5ef6f539d8a1524f155a7d2da825f42b11b80358d806d28934ef73014e863eeca74156d4b1b066ae11a875b746164095ed815b10478a37" + "cae6fa96fe16e9833397270fd531f7c1a9cfae0caad254e3b659e37e3fa9a1dcf07b48e101000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100012f" + "99f4cab34e65cdc3b60feb4f0695051098cfb971006b4b9f9080f3f51d7a7ad2d95fb29a1a8ee6b155ae37417cda856069b667779e39be" + "6e33cfc3a2481ce872e92720a9f4365d4f3dc9e745e373a580c017663a37d7546884f66dd49571c1b4db654a12227b1ddcec9251ce4235" + "9d7c49154164c22701eb04418f6d682a14e525979ddd052a718d75d213b7bd8cc3ba8b97e4dd357925bd063d6697deff85840366e31679" + "ccdbf2bf0db5016875abb19695a6ea59f221a64814ac5a4a99316b54b722614413139b97ca922179d1be5914f91b7d59538cfcc37b5898" + "3347acb7a138df8f3f1b9f15a9053a0d1d8677c517b508736723e1ccae5a501eb011569bd1d1dc71f75681c5871497a149bdd4c0cfe7ca" + "acca439faba11526aee5f280345555c81f09213e6d6699511cece3dcb1ef47694c3d2eada01653d565dd0f85a56b9bf35ed63f1dcffdec" + "73939a2bd962f67feb49aeca0395214d7d2430b6a9c43a93f49386ee99579a46ad9848138ca08c0c02c4036f538f41b708bd1ce3be00c6" + "4caff64bfbeafe65d19b245f3547b999d84163e51c200b91b762728e43d5eace6ebec90119be092ae6f131ea7b5d5901eda3b8cbca01f0" + "df7f98dc3aab37712c3b223d03510ce241cb81e5719fb8ee161a1346d8323397d2ab673695d5d08816f1c0fc61073eb33471d29d7ecdcd" + "083678709efd4b63e5f0a699ec19e949", + .hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", + .keySize = HKS_RSA_KEY_SIZE_4096, + + .encryptResult = HKS_SUCCESS, +}; +} // namespace - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); +class HksCryptoHalRsaEncrypt : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + uint32_t keyLen = testCaseParams.keyData.length() / 2; + HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; + for (uint32_t ii = 0; ii < keyLen; ii++) { + key.data[ii] = ReadHex((const uint8_t *)&testCaseParams.keyData[2 * ii]); + } + + uint32_t inLen = testCaseParams.hexData.length() / 2; + uint32_t outLen = inLen; + if (testCaseParams.usageSpec.padding == HKS_PADDING_PKCS1_V1_5) { + outLen = HKS_KEY_BYTES(testCaseParams.keySize); + } + + HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + for (uint32_t ii = 0; ii < inLen; ii++) { + message.data[ii] = ReadHex((const uint8_t *)&testCaseParams.hexData[2 * ii]); + } + + HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; + HksBlob tagAead = { .size = 0, .data = nullptr }; + + EXPECT_EQ(HksCryptoHalEncrypt(&key, &testCaseParams.usageSpec, &message, &cipherText, &tagAead), + testCaseParams.encryptResult); + HksFree(key.data); + HksFree(message.data); + HksFree(cipherText.data); } +}; - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalRsaEncrypt_001 + * @tc.name : HksCryptoHalRsaEncrypt_001 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_001_PARAMS); +} - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); +/** + * @tc.number : HksCryptoHalRsaEncrypt_002 + * @tc.name : HksCryptoHalRsaEncrypt_002 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-768-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_002, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_002_PARAMS); } /** - * @tc.number : HksCryptoHalRsaEncrypt_011 - * @tc.name : HksCryptoHalRsaEncrypt_011 - * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-3072-PKCS1Padding key. + * @tc.number : HksCryptoHalRsaEncrypt_003 + * @tc.name : HksCryptoHalRsaEncrypt_003 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-1024-NOPADDING key. */ -HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_011, Function | SmallTest | Level1) +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_003, Function | SmallTest | Level1) { - int32_t ret; + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_003_PARAMS); +} - uint32_t keyLen = strlen(RSA_3072_PKCS1PADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_PKCS1PADDING_KEY[2 * ii]); - } +/** + * @tc.number : HksCryptoHalRsaEncrypt_004 + * @tc.name : HksCryptoHalRsaEncrypt_004 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-2048-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_004, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_004_PARAMS); +} - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_PKCS1_V1_5, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; +/** + * @tc.number : HksCryptoHalRsaEncrypt_005 + * @tc.name : HksCryptoHalRsaEncrypt_005 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-3072-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_005, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_005_PARAMS); +} - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; +/** + * @tc.number : HksCryptoHalRsaEncrypt_006 + * @tc.name : HksCryptoHalRsaEncrypt_006 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-4096-NOPADDING key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_006, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_006_PARAMS); +} - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_3072); +/** + * @tc.number : HksCryptoHalRsaEncrypt_007 + * @tc.name : HksCryptoHalRsaEncrypt_007 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-512-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_007, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_007_PARAMS); +} - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } +/** + * @tc.number : HksCryptoHalRsaEncrypt_008 + * @tc.name : HksCryptoHalRsaEncrypt_008 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-768-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_008, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_008_PARAMS); +} - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; +/** + * @tc.number : HksCryptoHalRsaEncrypt_009 + * @tc.name : HksCryptoHalRsaEncrypt_009 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-1024-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_009, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_009_PARAMS); +} - HksBlob tagAead = { .size = 0, .data = nullptr }; +/** + * @tc.number : HksCryptoHalRsaEncrypt_010 + * @tc.name : HksCryptoHalRsaEncrypt_010 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-2048-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_010, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_010_PARAMS); +} - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); +/** + * @tc.number : HksCryptoHalRsaEncrypt_011 + * @tc.name : HksCryptoHalRsaEncrypt_011 + * @tc.desc : Using HksCryptoHalEncrypt Encrypt RSA-3072-PKCS1Padding key. + */ +HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_011, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_011_PARAMS); } /** @@ -795,42 +598,9 @@ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_011, Function | SmallTes */ HWTEST_F(HksCryptoHalRsaEncrypt, HksCryptoHalRsaEncrypt_012, Function | SmallTest | Level1) { - int32_t ret; - - uint32_t keyLen = strlen(RSA_4096_PKCS1PADDING_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_PKCS1PADDING_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_PKCS1_V1_5, - .digest = HKS_DIGEST_NONE, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = HKS_KEY_BYTES(HKS_RSA_KEY_SIZE_4096); - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen) }; - - HksBlob tagAead = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalEncrypt(&key, &usageSpec, &message, &cipherText, &tagAead); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); + RunTestCase(HKS_CRYPTO_HAL_RSA_ENCRYPT_012_PARAMS); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp index 810c5f83..43bd50fe 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_key.cpp @@ -22,35 +22,118 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -class HksCryptoHalRsaKey : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksKeySpec spec; -/** - * @tc.number : HksCryptoHalRsaKey_001 - * @tc.name : HksCryptoHalRsaKey_001 - * @tc.desc : Using HksCryptoHalGenerateKey Generate RSA-512bit key. - */ -HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_001, Function | SmallTest | Level1) -{ - int32_t ret; + HksErrorCode generateKeyResult; +}; - HksKeySpec spec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_001_PARAMS = { + .spec = { .algType = HKS_ALG_RSA, .keyLen = HKS_RSA_KEY_SIZE_512, .algParam = nullptr, - }; + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_002_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_768, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksBlob key = { .size = 0, .data = nullptr }; +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_003_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_1024, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - ret = HksCryptoHalGenerateKey(&spec, &key); +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_004_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_2048, + .algParam = nullptr, + }, #if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); + .generateKeyResult = HKS_SUCCESS, #else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, #endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_005_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_3072, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_KEY_006_PARAMS = { + .spec = { + .algType = HKS_ALG_RSA, + .keyLen = HKS_RSA_KEY_SIZE_4096, + .algParam = nullptr, + }, +#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) + .generateKeyResult = HKS_SUCCESS, +#else + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; +} // namespace + +class HksCryptoHalRsaKey : public HksCryptoHalCommon, public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + HksBlob key = { .size = 0, .data = nullptr }; + ASSERT_EQ(HksCryptoHalGenerateKey(&testCaseParams.spec, &key), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + ASSERT_NE((uint32_t)0, key.size); + ASSERT_NE(nullptr, key.data); + HksFree(key.data); + } + } +}; + +/** + * @tc.number : HksCryptoHalRsaKey_001 + * @tc.name : HksCryptoHalRsaKey_001 + * @tc.desc : Using HksCryptoHalGenerateKey Generate RSA-512bit key. + */ +HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_001, Function | SmallTest | Level1) +{ + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_001_PARAMS); } /** @@ -60,25 +143,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_001, Function | SmallTest | Leve */ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_002, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_768, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_002_PARAMS); } /** @@ -88,25 +153,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_002, Function | SmallTest | Leve */ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_003, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_1024, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_003_PARAMS); } /** @@ -116,25 +163,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_003, Function | SmallTest | Leve */ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_004, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_2048, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_004_PARAMS); } /** @@ -144,25 +173,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_004, Function | SmallTest | Leve */ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_005, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_3072, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_005_PARAMS); } /** @@ -172,25 +183,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_005, Function | SmallTest | Leve */ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_006, Function | SmallTest | Level1) { - int32_t ret; - - HksKeySpec spec = { - .algType = HKS_ALG_RSA, - .keyLen = HKS_RSA_KEY_SIZE_4096, - .algParam = nullptr, - }; - - HksBlob key = { .size = 0, .data = nullptr }; - - ret = HksCryptoHalGenerateKey(&spec, &key); -#if defined(HKS_SUPPORT_RSA_C) && defined(HKS_SUPPORT_RSA_GENERATE_KEY) - ASSERT_EQ(HKS_SUCCESS, ret); - ASSERT_NE((uint32_t)0, key.size); - ASSERT_NE(nullptr, key.data); - HksFree(key.data); -#else - ASSERT_EQ(HKS_ERROR_NOT_SUPPORTED, ret); -#endif + RunTestCase(HKS_CRYPTO_HAL_RSA_KEY_006_PARAMS); } /** @@ -222,4 +215,7 @@ HWTEST_F(HksCryptoHalRsaKey, HksCryptoHalRsaKey_007, Function | SmallTest | Leve HKS_FREE_BLOB(key); HKS_FREE_BLOB(keyOut); } -} // namespace \ No newline at end of file +} // namespace UnitTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp index a7ce58ec..94077866 100755 --- a/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp +++ b/frameworks/huks_standard/main/crypto_engine/test/unittest/hks_crypto_hal_rsa_oaep_decrypt.cpp @@ -22,538 +22,72 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace UnitTest { namespace { -namespace { -const char RSA_2048_OAEPSHA1_KEY[] = - "0100000000080000000100000001000000010000c594f464bc7852f61e96a56ffab6d1ee5cc5552e51ce5426b17b8fb50cefadecb0ef2e" - "9402906b9460f2dc527188a346e964acdc3357c2dcc56be8247243350cd9dc122dac3f37f4d22870e9b6d5524d43fadf5cb3a5386ebc11" - "4fc830faa624155526fc893bf7848451827c68c3610932a7a97a55c371340b86b4ba1aeacdc0185a7ac78511947bec87bbbfe011baa45b" - "19d7f7eb0accc77502f26ebb0d4797b3cf1a32116f9cd9f0ad4977d2881cb61d0439099c77e3e59aeb4386ca545cf534453c55d7b548e3" - "de6cc513374cbe312eb6564d476859307dd47498df59dfeaade0a8339754fb3a192cd64bad563c861b505d05b54a6254903ebfdfc6beb7" - "79000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000010001691598061bd7430873ac5bc0faef51281d5f" - "36b6b3fbb0f6035f5c4746e212f6d803de1a0a6315548d5b9da29b8fb887768a7d0580a9249296cd95620d0381ab9c1357f7c2acbcee10" - "f841558c5058bd8f725669cf8208499cecf829d922f64a2aae6755d90773d59f2a5ae4203409e00278f9c27eeabbc29a7ec29058d0992c" - "a911b57a2af8a582caaa3add2aec200127e95e9032a8a4c546fab425148dc2c72ff487ad05bf0dcd278024e74d0e010f5aab57eaa5dc8d" - "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" - "adf95c1f761b56c8ddf2e78e532861cef681"; -const char RSA_3072_OAEPSHA1_KEY[] = - "01000000000c0000800100008001000080010000c50e4fe8739a73a3627e504ffd323bb95057417d2b23fac0939c6e3c43c19450b38733" - "19275612866f0e8d349585c17bffa9c13389975916f2235161fca6a655b4c0a3c833789a18a9add01f837da762b5acdf29f296324b4d5f" - "7f586f900566d949f4784b935503b4105e2c6e83d43d6d17e07545eac427be17f0fd7b08fab210f38bfb405ca524877d5c039505a0a9d7" - "c2e24e9367a8a13e2fb9e3e1dd7b72936737b0590ce3cc9262284ed041c2b362ed3b617bf879256e69be4357c027dc66d5afc0a4d35a2d" - "cc6b42344bf55b90985aea8d2604af1ad404fa8dd9014c21da00a2587c82f97045b8be3593a41d71307f5b3295964257ab8d7ab8521b47" - "29dba792af69655296577ca175d974e64ed33881c905649b8a6bbb13ac1cb1cafc6ad61af81d3a0813eb1107d0d953607a1e99657de527" - "c108ce22c06f8585751f071efd87e7e874e01c17714ce73c2b619594119030f54f9c88158b8d64ffdbde582c3340898c18762458bec67b" - "a306aca31268accd72a4382c6e06b35a01f673000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000100012ce1e0a3724938937b288804600824004663496048062ee3d3fb2a4481ae42a8caeb3d613a" - "4b6976c32ece4caecdc34f09e15146faccc516ebd9cd7c82fe361e8947e346032b31f5f217cbb291d179e18abdb02aaebd35015fc3238f" - "3201dca91b4eb3e6fe57b5625d8de8d537eac0d9a8d26a666ba158423112e4e9e72f19629b67cd7751a6885ab49d81eab2f3902f7f1c3d" - "4d665792d9feff01d8fca5e4ab2915b6626d35f960abeabd818dff9c681d5d294c3fdf4d409050776c813d1c16b9ae28a78057a4a47e77" - "c62071a0da7d8cef186a98f2c95b16394689534726d18fa8b0526c40d64bb13f579532fc56e9ff2fdf95f0df3ab8493264ed098cb57e8c" - "fe9cbce24a5bdbea355ede53246798c79599d7aee1ac380ed8ee77f08276c617fee8a8989c116407e8d7a481ff77ef32f7405b5736b36a" - "593925cf15c3da1965f84eb4153a7d557a790a869fb99290dca0b4d6a97bc0ed32fa41eba3a27b9379e3f2b140e7d1e0a315af6561c5ff" - "1c894ad34cb998b6eeaeec5d3785bddfc1"; -const char RSA_4096_OAEPSHA1_KEY[] = - "0100000000100000000200000002000000020000b3166774620460ff0b4fd912c441a184527d8b6bcf1d4fe22791bd0a79b9cdb4afc944" - "532e948aa190ec27869df84384f0921abf036181369db2ec71011f3f2ea1b1a0f8521cdb75a47e1051e68d3220248b9e68303780247fba" - "99610d7309a99087c6da95a0f3bd5abdf703693bc7285a0a30944e132015370f9d263f44b8b2d05ed32470096eb6c7309e6c62d74cf99e" - "72ee94e8e1bbbcc902935762c6a5e3297e4766fc49867e7768f40902d87a219d92c196caa030a206ab75c02a4fbc4d0803d082fd328613" - "9315489f52b591caff2827d70d8839f47fb4195dc6036f3718987b56e6c772a30694cf983671ad6b93e1ec99ff94125a6268b1e556671d" - "11d41eeaec4c5e642534243dc5f4edd64190dcab9497298d8101ed7c3a97b4f28c892cdb2e3adc67bca83862429d82e8f6c40b72d7dc39" - "1b214c09da284a7aeed2a21914dd0aa3ffa0c97800b8c37198e92a5ed1c12788c9313d3bddf5436cf17c1e481e7613fe8a04cb8e5c14f9" - "8c450f4df4a3f77e548615adc6face54baf5f60a140759ad341aafe0187d9f05745f094b547dc4bb3ad5b2be64dc10e000e555c7a09282" - "e7ceeb8d99e1fbc64e57409f644fe5e877735695222347ce556fa340188ed74df9ebb26f7205206a94b9eba96da988e13ad273b931a9f7" - "6e501f371e789cb2a1249056076e50091949bb9ace7af104cd9db3e03d832a4c3e6fdb9c87000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000170" - "d46ab5ae9367b1082574741865e926fef9cdff4c6c014a50f7c70c7488958b833ce0e92f6db2b1fc266cf8a94a22effcc970446c12e05f" - "d29749d4208ad939bdf1b5a2fdc8e49387e14cd2ecd8847e2fc82f33213db664487cfde96199daba942e97205c291da76d26461c460ebd" - "7934d13aae154a836a1a58a1ffd8d8a92d2f8eaea4445a0d00e71a4095b4e844bcf8111d33804dc80436f8827009f171ce5ef40a745dfa" - "ccdb9ccbe9044c60ab01c6cf115cb9a8973b5dcc64d17f56e121ff2cb80fef0a07e30945dd8d5384c5a8097df92bca80cb52b9aa7458da" - "4a8ba540bfc0e58d5c976312e06ab2518ae961dfb7f56348dcb77b6e88db9bcc06070f871c5f38d10e16c686e51a78a7d54a78e7ba0d5f" - "a5c42c4a401529890f5f697ae567a0e5583f49e73f2ee735dba5d0b15df3f0195a48de70120eead966126f161bb57d770cff988500ed1e" - "49739298692a55764756eb3930ddcd035f36f121b242d21bb4088bf176a3a98045e25ef9347d2a2438fedb024765d80b7a6b4d5b0edff1" - "dc96854afae97c3b6bb40793f78e93972a8080b87934ef9e014087ad5c794dfd6313cef45d72d9be592846a5c4414b2570de994b467db7" - "8f068d0886fc1d67a36f80f556b5913a55da31fc193718e74dc3275c224875eecad8a353183244c4c73c2bb6b96a5ce84c5c8992b43eb7" - "2ed71af821a658f473f0a3a283f40d41"; -const char RSA_2048_OAEPSHA224_KEY[] = - "0100000000080000000100000001000000010000d44c2eba9c805a2e00397ba68b54ded3d626b02b93d72664f97e023ecf5d4974388aac" - "ab0983529acc1302beef7975cf9db43a4a422b258bc3db75fdba50fd67bd009a44a248b712638589c6d5115aeb8b320c04401400c3a0d8" - "6684337937ff2259330c06dfbd652497fbdf5722dcc8a4d583f59ad1a02eca4a964516a23a06c4398d4edd2c977e7b85d41f303f62bfb9" - "3ff65e9e837e8d3c6f1c9c9d067a0df7c36a0c196349d2cfc1d82c5daa60935171e42754447ce60328abbcbba6078c39ccda078cf88adc" - "1dbfbc645a401fe386b57b5edc94d5bc8fc7e2c3cac6608fe8d91e69ea9fb17f6b7b42ae794fbe82e12cfa4ce60a11de5e83c315b902d5" - "c9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000100014aba8a545bd47e69e4e0571b37be67355013" - "8c3dbaaba83330f35f1cf6e7527cdb8e4cdb63dcdb0dec39e0e48eed454010b629328c7a1d9c461411437ffb144818ea86631470de2855" - "e9e2a69fc79d267e77de6cfc954df38ec1bdcc59461924f0d54f37b38fbc5e46f44ccfc01f60722c3b9058bae7812817430c0443c45501" - "fa69778115a748a79b89d1e99c7791516a2f7d19114cbbd4ed7827b51ff8caee4dee84f16ed0a1b497513be6d563fc5ee7d0891c523e8c" - "0c0be002f7edc638607ba45647166342b004d1cc7a31a3492d8980b9a3f2151a4aa2cd8bdac7b1652d791e6915730bc9de98ac1a3b5fd8" - "2c26ae2da515146886c78090a7aa8c31ecf5"; -const char RSA_3072_OAEPSHA224_KEY[] = - "01000000000c0000800100008001000080010000dc3d6c0fb6da1679390202196baa6a999f217a7ed8ba8a3d309bcdff755094dd09bc41" - "77ea6ed014ee412051b2c02f851f32e4400c894ec6da6b510d613536c32f2dbce41d4b9196c24ade4edbde812e8eb2a774bad179c7bc4b" - "aa338fa2cd67d5e6b868b042b7fc0120fcf2e8e104a3dbc35c250fc91e486565e8928d5d047d0bae93ff09d9351157e5a000073935b09f" - "4bc7e5b25e2287f44ac8daed8e0e5db021359ec22acd2a1d374d82d7ddfbedd7ffe6a09e52fe8d23a751665fd8b36a456fea4d69900a7a" - "623d92c6a28e56d80561e3123a99c49253058177cff12a06c8e4d77563f0367f5ebaa8f5d71750c721fb6a6dee9d28a97c7474692f60f5" - "528f3a1e02234c93fd895e62f40a9c44ed62cf37c52e1c4f582350c6ca7991a6468cf4dd75b556cffb09c6b69c4719d00196f4bbe1dce1" - "204bbc5a673fc81fbac0a8e2fbfc7d4f87ef3e1a501da79226ff984e440731c7a2d8882aafe3d8195dfbcd8c8665e9e1bb334fc9b64ec6" - "b22f38015a9e797b3a509b8efb44541344a64f000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000100019570a40361aa47b7878422528768c21e6d08b56a9ebaac946a883dd60a0f5c834358d6ff7c" - "3626c11d0d59d5b5b98c4502ef704b39766ddaa6584d4e0bd8a4c8fa1949e36b315c9f744482e5f570dc2cf02caf4d987a0ced078a3bf9" - "f28ba05ec5986126bffaf5866c69aad9544562f5a067c5fd6be1a6c7aeede04a98db35f1775cc51537e4878ab61e9c5b888b3c301556c1" - "53cd9cec475deee4ad10a5e47f93c464f2cd8367651d1fea5b4f08542a85f720d179bc8cf6cdeb796342c3f2b0756daf51eda214a3e49e" - "23fa8682ca429d1f5bdb6488baa9595272ceb55517fda0eb723256c50fb151a175d73a117508213b7e6d3be0eac0f6c349b5af0d77f22a" - "5bdc22cdab221cb8e474011122e67d195a00ce9dd821242df8eebde04770527d559370e93b7f8c7e882db778b6255d487d2119acfd81bd" - "0363e27d27486d14df9407e8290916064230a638782b4a1b02582c1841703f88d0555357d9c0a2052d9d6bb7d7e5e1302c466eaa621e4b" - "4c6b42f0a1bf2588695018a295ebd7f031"; -const char RSA_4096_OAEPSHA224_KEY[] = - "0100000000100000000200000002000000020000bd0d9010dd30b0ec8c396744527127508359e0f12aa4b8b09dc20f42040644d4b33f90" - "de38ce815367af5a8cabf18a71732d569bcda767767ae0b61f38108a021d197b2e097e60cad6ff186a3510667a4e19eca53abca79dbc57" - "8e0d30ba42146946c1f5fcd6204e17252be83121554ca68637e85e5534d1f2c943831d9a65de22c70812872ec219cd2ede8c8c3e78a5d5" - "250b3edf4bb4bfd9a9232f2dd2902b61eca43038d354a365dcacc623de3b062207f7807c9d877a603e2c70ae129c5d418fe52f023025d2" - "68b0627c0dbf1488fa078fb187b57c17c86a43116f94622c5ba31c4ca771428fb73c8b9ee7ff21962dad6b2094c83823f413bd8ec23648" - "186c34a2ba9f0d972af78d7882bedd926faffc6944c4d4211888fa4a49ced7f558d30929041d93a8c5d2275e0330909cb201a618f5a747" - "edc459189b7d30426c49a0d10646a10f015f1e418370874ec2ab0304515178c9fb4425b7c4747e6fef0981b8d599cd3c1152ed804a79b8" - "9737a5344848a4b36ccc9a29b7fd58ec854a5457fb9b24f192959050ea793b8f17d27cb8cd809b9b87957889947576137868bb30bd4810" - "c421b6e937fbb554f9345e266cab23623970f94df74a0a6321487fa655933f45a1fdff7252aad1230e518503ca22ff815d6427acdb57df" - "b7480bd4fda526470c7a3187ea980db8b75b486d77844e030821b804f32b56b75994b96a11000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000116" - "9c2ea4b5af83196753de33dfa044d16e442b90ec46b307fc761f19081e2fd13876dbbe9810aa8aed159dc0c137ac15116f54b2619029e1" - "93a49863777312ee59c89860d325d831aa30ec1c97a814798029bd91ad4aaec940a3400bf7cdeee53e0a065c8316a0da760e2e08210819" - "898748fa1ac25d7269c19dac835be10159e5d2e3f64350a64a2badf553ddda02d7e27c01b24d4662a1a748813abd423797d8a852a2a9c9" - "2c90363884395644d7ce4df7a1f42df33126c3a7ebecb604e7ca8772cc38290cd5192b081d5f34cdab890e4e25335845ae47b1e2738efc" - "4744ce854f26ad4c4151729ab995013641df2474e60eafe0db694b737f80e637f801fb25223a924e96341ecd43fde54a977bd668c5a9a3" - "95dfe66562891c211e888e68ec740f05e5cbf3776774689b83453463a226d4dfa263dafee68378af41c5391bea2588f356799578bc5b67" - "e6382f5739a428589429c9fa66bc8a418ed6a353a09f92efecc9029f51eedf9f98134310cc11ec064fb6e5c9266b0aa88d42e8e574f3fd" - "2f3da8e34a310324b42bec03945c67b54915f82eab1936972a2ae42ac1d71f3c552b39a3a62e25b7b38dcab1c4b71b89445dc563a158b8" - "614a5d4c4792e3e9c1e4aad4a854930f63a476441d90422e1a671b0fbbeda2015b189756e421c8e7a6253e354c7e116ed50cb410bdedf5" - "5689eeac4e8eb71c16fc15829b821b21"; -const char RSA_2048_OAEPSHA256_KEY[] = - "0100000000080000000100000001000000010000c4f60d18cea8dd8e0635c77ced7180a2e876d85668a2f93eefc831bf5a7df549303737" - "7c78ef3abb295a0a3c61c1ee95200c5422ff0e320596e5911f40951b587308182a1564c852a0dc8e4949e01a7a63459f1eac07d46c9728" - "e865c68fb8cc8c94d087066e84169089f1bd1ca9279729dc2330182ee482eaeb9fbc4cc131e9da0ab86c161e7a019ea08b6b2899f8f76f" - "8dcd27e65f7c92ccb0947d6834ed05242b08bd4faca3910119271bc3de7775c53acb92aad7c3d323372c4d149d140ac1f66172d6a932ee" - "80bf123a4558c64a7ad25b912ac233aa599eda965e271ac065c68909634e18efeaa951c35b2424298633c3fe8783deba92e22be1dc662a" - "e5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000010001454527fc068a9b491ce40321ebbc547a76f9" - "7d427e907aca68b866ce9ebbd7ed829898da1d0a3e049f197caa19d383de4ca4295f1986db8eddb02566f166bf744f1894af10511ea6f8" - "ce38f88b93d69c1e97d8cb87c345315fc4525fa102e102879abaf012120240915b027af93e809f0868d4b3507e057e09b30ebdc1dcdc79" - "7d30d27f750c35e1ef66d1aae17a283aa29d7f0552d49fc8b2792cb4c3f8bb8fc437d334231213c2b0d671e63502a2c3b95cbd1b424c39" - "1c17ac851268117c736d2dd28898c69c0c8467a5588b2c6e1d8bd21bcaacc524da0fafcee2d869aa0047a51c2c7624d4b9400c2b2109c0" - "5b2b7d1a9141887cae78911e04a35adfd341"; -const char RSA_3072_OAEPSHA256_KEY[] = - "01000000000c0000800100008001000080010000ee5f706a43d3f09582c6f0a7677e2f7695ffd50df34c0bdefe9710d3be0b08b6225f90" - "f4b27bf4163cbfd0e088a85cbbab9d99ca499a7e33e46b7c8dbd49dc5c017c18409887ae7c67529ba4b76b534cfdf7a6b9f7dff7411e35" - "958879e8c912229ac0a30d989aef962b97e8fe2c5029db5f51ab7deb6e4341063853d3318bc21f799d77b37302e976e2207f0672cb828a" - "8b609a996dd519d54bf7dd051286b9e0b0447e789de7d724ebbdb61c5dd38b677af6470bf5dbff39ee5f7a6f811772ab9d38f1c42e371a" - "6698948e505e3b096917c658aa5d0a48290f98cfd7219c324a6bcfcc66e244ed48013b52eb5a7bef7786f80089cb4b2f5ff1a8365464ad" - "85f50e962c08d1cba6c7b2ba0dcb6af91cff35d5d834c224ee0adb6c4656ec575cdbce4fd60bc6d6d05597d70c92a2673e24f94f515e8d" - "c8137e5efda4d5f8e51b42d6ce8186472bc92915da9995809b21d2f371c8d0840802af0afd43cd76cc914eb3a958f7c6bf05ba4705e2cc" - "c8f85de9da4f5439da35a639fa326273f228a9000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000001000107e57b78d9b45ca4e74725d3b5d6f5458d64832f4a1efbc9b04f5acc58e04eb291e2ee8f5c" - "964498b3fc7ab3e57306576530fc563a27f7044b0dd07b7588cbd6f469a2f808d57dcf3b30fe5cef828ba8e244e0ee0a2b0e2ac710695a" - "b307261a06b16fae37161613d7baabf698ece8deea1877412213b97c5adc14e399fc6b2fcc11204945d58a84275f084a8cf12292b97a32" - "820c9119dd1836c3083c51c7cac289b44b283dbadf62a6b88b1ed770d98e5d01698b18e2e7ca887dfb3554666d62a954f1e99fd0006b1e" - "8b67eaecbdb0d3f918a880f0ce5cacc614dc81cc2029ead91ebec3afff48e704827e41316a55874950d0801f04b55177cec74c32f8fb87" - "c4102d8a5a8a7440416d1664587ec80538c80c22ea0223163f44c9f3ddf3b504620246e26d58b17bca0714ebbf98d916cea6d88dcea325" - "aaa7a22d184151b4285acee2ed6c064dfe0734e796298a8a5acb8a84462487be3b4629306f08fa2e507427d9bdf2a01b106fa832804861" - "012515bbb4503485c38a5895dd5c41575d"; -const char RSA_4096_OAEPSHA256_KEY[] = - "0100000000100000000200000002000000020000bd242191c7b58734f519b77d69978689267e81ceae91c334890fb7e8391b9971947dc1" - "a1919cf3e60cc783ef51c3702fa2592f4e0060a5a03f2d3737ce9f2f6813b6fa2244835c739d3b8065c52a0aef6924f648a4a7d65e49dc" - "4d95c7265a48ea4ecc231af6b5a78acd94eb29d1a59c0c474510c8c74c087e89dbece00273baf31d2c915357e301d72ba33521537c3a19" - "fef215b1416ed04cafe06c85c78abcc60553a6444f0bdef3bb58864d52a23d8447da98655632f8249d4602b1cb99f467c99d6429bba5d6" - "cea31db9548178312db72d8cce5f8559b76b77efec3e19eba97eb984ac9232b9a84087335bdcbe2bd50d04e70ca0b99e0091b8a3b2818f" - "905b9e894858db311cae379946941adb85b03ec13d53b5527ccbac90bf8052bb0ff33becdc1f2f493e4020ebbf1778dfae67942f8c08a5" - "c069647de3532eecc3837d3b635c7ed8eadbb60adbfe52792b4de89ddf410a98dc59964dab256e20bc6558cdb7f7b7ae559057dd0f116b" - "9250af84124a6d9d72ec69b2c756a1e711b6aa62a5a01140aca5e57aee6f738eb3093940cae3106711596b080619d34390c776804551e3" - "315812b23a9e309f5f2a6a204516a4585721333b7db48ce6545325030a14f729c2a095bd98cccd21de27f84126c2e60ce261fa64879ef4" - "dee4e40883d67b5f6389b3ae1e8c9018c96c2a62b5844bb6f556aa433d77a4fbe3d0261da1000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000184" - "77e5bb0030373df3dbcb135efced10e990f8c114aaaa190555a8ec4ff2f0890802fbb679118010c32a8950f7e6f58fa718e774adf70289" - "353629d24038652f737f57b8e05b5048f8fa4f76f79bf684af13601a8897b41fdd831a23a89347f0818a2696ffaf8292913862f0411dbf" - "eb86fdf37549e9ab6ad7951e1eccd56ad0a8acea25ee45438c6a72f99fa073a431dd3b1db9eba774411734a6eddad4626acc15b6fc6023" - "2ca13dfb1c891366a892852efdfe761ae51fbe25187f929e927906a7c24000aa97ffd6418ff3d927c4524d3e59fca01d6e7be366b55da8" - "0be68392f65a607dacf731e891291fe35abb265fd4fa7607f6198a7bc39399b2cfe30775240fae0f0db1239e8b072a580f4d5ed2a9194e" - "31c11bca7c6903e36e2224a9a9b1926dd500f1aa6cdbd2030ace1fcdcee9aedaefc477ad5bdaf88787d53cc83d2f00f25aa0f57afca753" - "de2368c7f70245bd92ccef7a30b9f799a328f658d7a285265a3f03d10eeb7d4a4d42ee202ee2f54d182fe88d46608949f337b1b7a2691b" - "0db4e8457ec437f921431cb40adc52163957bb2da94a4b7d6f80c38ba5d0febe3504826f279795ba72d358882d932e9bb85f5bee0d46b5" - "e8e91bf2940ddd8ae7ef274f562eb4d47e380eae720f05293830313bfba820ffd71581a95cf50e4429ef9a020d43a09fa9a55fe1b2f6f2" - "936d4168586db9160b14f3c8844d81f1"; -const char RSA_2048_OAEP_SHA384[] = - "0100000000080000000100000001000000010000b7e7b8fe8778adaac50fd7935451726c84b0f60dacbb9462140d50a39d065fce6bacaa" - "d29bd9d6972e732304c30ee967676d8062c56e5ba6328e651a7afba7f0992806d08f575389683f412a63049c49200f42f9410651a946a5" - "130f3cb10e6d8e04520af779b4d6d192578540efb66687a896cb3d0839692f4f1853697e9f8def35a94f6fb206b6375ad9e6c5e8c27eca" - "4c25de185ded5793d0be50f882a124c4cf9774621872725e6365e6525a2d61d8558ed385c6a15b8b94b5548c42313c51229a3c3e5161a5" - "d0c573808a30ec94f5ed907d250070b069a9ddf2ad666018a9f549dabdf8f333c6414c9acd3a3565770eaed7843cb775d22f7d790b97b8" - "13000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "000000000000000000000000000000000000000000000000000000000000000000000100018d1063a86985b9c0c9d3b30a419d0fe6098a" - "2bd2a57265092e54604c800009b12e8a8da56b029745f3cd41493fcdca5f14c8bbb807b4f4fbf0bfa4f1c0f0140bcb8f165b17f8660d7a" - "373ae72678bce0a284d25c9af21be57a58d8dbd13406db261a4e4c3733d5f10963f55a334b2c604d229638632251d74b00a2aa28bb85ea" - "6e6fa3e9d4fb4e8b2a9f4aed3c2e84e488197383c457acb426babf2821b40a7a2b8c9a624964e8b223f20428e9d02ad13ecdc426858c17" - "2070924068d97856b56ffaf5d47e643bcbc39d85fa425d93c99905301ff10fc15ec2c2bf49228b69cbb50895ecef1140cb05bbf314157e" - "c8c21796b1eebea225357a4a8b89385eb141"; -const char RSA_3072_OAEPSHA384_KEY[] = - "01000000000c0000800100008001000080010000ae9c2597d382b1cf800c1066c2f0fddd8e6e0d3d7f60b33066291cf20ea84f9d54803f" - "e6829e80799989c4b95f92424237909b5a1cfe9f99890a98e4a80548523276c4cd421dc8220c673d21255c29daa8862551ab5c6c19684c" - "8ab11ed43bae6da8184a0a97791f7b3d7b5cd33f7cbd6b2b4847f6a8bc3764faa7593763f5a3fc253e616e73fe26eb08aa3060d40be98e" - "f95c39ba7d8ef3528760b8c5c9c8b7a7f74f87498e3c33a76d4c94863fa9a3d7aa88019eee6a35ccc43d7dad5f8a0fef2cdba741f900cd" - "53e8155c4a90f4f79c7892d445e7da3d6a2496a4ca32ec8fa325bad6ab0bfc4911bce78be03ed0043f7c5fee60d4b10c7412301c6dfd36" - "8093b9ab12dfc61d403b7905ec78327b384c94f31059021b6cdefcf8440e1ca74ba5eb98d27c158825a8b7a648c8d0a23c28d15eec8924" - "058ea9d08fcdbc99f2bbe017228012861df4fdadfc20f58600b2240c7a0048ebb2ea2d8f846a97057c6fdc5b1cf916095fd51659063400" - "9bd94a988ffcd2007ddd46aad6918bbd3bcbd9000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000100014cbc00655da56500fc93d0ad6864421c98d8526741503ccf3b463c1b4047c55d2de282b289" - "9aa0794ff95483e6b53efb1cb227238df4742d24258d1587a572a7f4d76f1b893fcf50ef447b7fd28c53346db52e375ae86df52879e2c5" - "7df7e5167dc84e8c536547ec86db79184d19ec76cddf228fc59d57c1bc55cf2f8d0117d56e1cebf22379442ad445658d873008e0265dfd" - "a2bd0b2ac451f37e95150edd6fa09835d20d883d7ab1cc7dc813cb6c80bd698b05b353b1475d6aac5f4bceddbbf3040f17f701e60a945c" - "cc12e90354b6c508084570a3058dde4e0253e961c014547a2ce41c5b9ba04704329595cfc1b451736658cd3e6734e30864f1a083801c14" - "fd309c4e116329c5f0d6c12012126267dff44a47d4d6fd2f6e8a4c0c50e14bcd3cd856ba26894451513e139baadf3a2f992f22532afb8c" - "c7607413b7d42230c8c06299b46117706658653f838d32a8de41d8ed7ea779ed1a94029cfbb3f4527bceb5ceb700fa20bb5e5f463e17c3" - "10ce7fe7cef8179d5cf7924697551d7301"; -const char RSA_4096_OAEPSHA384_KEY[] = - "0100000000100000000200000002000000020000a92637cd544520cdb67f0aee8c620047937df05133af415e2644873f2a04a8b5d1ed19" - "667e0aa5b0a859c0f881f872067e208c98ce775de153ce95593659e3e4133229749293f83af9d5b6d15b35f0582a3b20bb7d243c5b161f" - "a1326ad5402b1bd1f0e7da929ed5601e5abbadee4243ed6bd364aee814788a6204efc2e6a4b1172f79215c02c49ab1c3e2f9c9cd03e35e" - "27acb023fd724095b0b68ef069a746067516093168f84d6040c64d448680bd01f5af31e78a57b0f6e36d4274f54244d5df0304c3fc9d32" - "083771cf322dd31a4e02b9a55caf68bc919848cc126802e5883e015f6dc48f9de821b1c83142b674a374fd7d0cb37483824ea9efe0151d" - "eab15e6ea8f54262b80b6036f6151c82ee6804d003269163ab52bc62ef6b8e1649975bfae50bb8b22cf4f1cd518c9e11aecca3905bb1d4" - "866fab531ba1531748e8722a7d12d3ee52014ad6919f10feccaa1bc3386b951bfb8587c7694cadb9d3be984a706d40505bf7dfe1963efb" - "52fd1ac8e612a42ed934b7e0f132b9118ae13361f914b27a5ff1a7b0f0c27788d737410247c2e25124c982926972b87f35e1e2a4529235" - "04474dd8981ad18b0424ff40754a271652bfb35acffcd25c46afd5a69ab1365e7259b05f04b12bebc7ec1361e909359deec133c7c4b58f" - "bfb2b8fefa21df15955e31b688bcdfb1e857d955af09e5b724b9a11dbb3cc7f1418f09995d000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000104" - "63e68ce0c40e8ee84eb1d4f135d5f605a0fe2ccd5f9e1db8768ce019d21722e8f8f370d292aa2c44a257bcdb7abc52e8d125750dded143" - "f8ede2b8770dac398e39fe13757e7bb1e42c24db9837752e84a2163e67881a3ceefd112d02d2d820864f53a660e8ef5070773939a7d108" - "4d450b48685395d87a2c7550d57c448a3fc26f4c008ea7cfbc8822a27083495bf179cf23cf4a8fd8784eaa5082b340bac3b9852e763c9f" - "11dac845c61fd948786cef711604009379a5313343f1b6a16affe8612a6de43c5944242c743ac17da8fe04ca5351346fa51347e020fb92" - "faba208501befd6016faf749401ea2288d27b92d48eb0f64d5ff8f2e41a66d806e6be151b4f2c409e0b8035ea2d63e9baf538a122e5e5b" - "02c41f11c218cb4e86665c11efd861a325a03fce577de17928da5a2fdb0786de366758c7d89514c3136da75a7095565e9bfdbe3932606d" - "dc43d631025828cb95703d1a7907c181126af324f5801531535bac8a6714204e46ea683d287c4c52f92f0f73715a5b8311d136aedb9a69" - "608e18be69e85a8c12b486bcf72f9a3c1f1dc01b5c77defa6b66999eabc14337d39183fa82bbd9de7f12ece728cc3b523e342c21363e52" - "4c8ba57b32835e06b8695022991d123afcaa7c6bee5802616b8ba5507e1276c0f472feedb3fd0a5c3f4bd2adc986c78d079d210537be05" - "a47eca98a7546b10c94e5f12a81b0921"; -const char RSA_2048_OAEPSHA512_KEY[] = - "0100000000080000000100000001000000010000c594f464bc7852f61e96a56ffab6d1ee5cc5552e51ce5426b17b8fb50cefadecb0ef2e" - "9402906b9460f2dc527188a346e964acdc3357c2dcc56be8247243350cd9dc122dac3f37f4d22870e9b6d5524d43fadf5cb3a5386ebc11" - "4fc830faa624155526fc893bf7848451827c68c3610932a7a97a55c371340b86b4ba1aeacdc0185a7ac78511947bec87bbbfe011baa45b" - "19d7f7eb0accc77502f26ebb0d4797b3cf1a32116f9cd9f0ad4977d2881cb61d0439099c77e3e59aeb4386ca545cf534453c55d7b548e3" - "de6cc513374cbe312eb6564d476859307dd47498df59dfeaade0a8339754fb3a192cd64bad563c861b505d05b54a6254903ebfdfc6beb7" - "79000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000010001691598061bd7430873ac5bc0faef51281d5f" - "36b6b3fbb0f6035f5c4746e212f6d803de1a0a6315548d5b9da29b8fb887768a7d0580a9249296cd95620d0381ab9c1357f7c2acbcee10" - "f841558c5058bd8f725669cf8208499cecf829d922f64a2aae6755d90773d59f2a5ae4203409e00278f9c27eeabbc29a7ec29058d0992c" - "a911b57a2af8a582caaa3add2aec200127e95e9032a8a4c546fab425148dc2c72ff487ad05bf0dcd278024e74d0e010f5aab57eaa5dc8d" - "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" - "adf95c1f761b56c8ddf2e78e532861cef681"; -const char RSA_3072_OAEPSHA512_KEY[] = - "01000000000c000080010000800100008001000098d7dc7ba96338aa0f01393fe4c848f9491c9e6851e8869eac27736dfffc30347c7723" - "457f79082f61a2188ebbcd1906137e7369f5e6fa5220062938465456a46367e9551c1dea7f616343f2bd6078a89b24d10b7bc08fda6d95" - "fb9414bdc869e3449abf06b314149bd5a6f0dbbb195476ca4ee29ec65405a0b8f1225b890d6e7ee2cc39c1551f7a1fa42981bb98cf5939" - "83c5985bbb13eb545d57c46e9d60a05b50d0bc3518606ba5735c00607068556bcfd788926f0660fbe386777befc53dbec3a26c61405dc5" - "92da9c8aea3b87299e0c186eeaeabfce7c4f0a67fe952411fe62cf6007a1c28eb7e91316d72e054857136b8b75b74eefae1278adeb5c60" - "ef79f5ff9197d67cc0ca8564bb6110bf5e1e2fa915b05fd9d6bfc74b1fed176167638c3af06f5b016b5aa368297952830870de51040160" - "33535b0948b6b8c548db76cd13dfc20742e194ffbcea4c491f884e4d598987b0ef86a11b771b8e244a9677ee29ac104588f45f90c9b0b8" - "2145ee35c324e6ef9007fa424743d00e3cdc39000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000100014ab39e1876967f1866d303471e2b61b72d2ba6a477fbfce7ca5e51c55e8ac488b2988c0da8" - "9ae00c405cb841f2b9f0540eed0bbdab28e409858b5d541ad397b12ac09bc33445ced9c9207a1246cac2ce2d5d962a55a6ace8660d1af3" - "aa1b83bb750f8fce7398cce4b1b17fb152c3a442aaf8800bb4ec5c1e900a3418c5c23b6558f0c23e2c26cd86a3b6596f05e04edf5e03f0" - "6c61d112903f208c07fec43e78c188c32c698aeb7d51550b8f479348fb0f017b674da2a3ec7cd01c65839691c0b58139e1b3d827c3961a" - "26d9d64fc676955e4b09ab58d4cbcdd15d34cb6da228a9b709dc87cb6a0f6826303e082aa16c27837fd62b42682313e3e9dcff90b06aa5" - "318704f4260c03c41ef580a70a2fe4cad7ea2a4f4793173e0c49d7995a04bb97d8bf77fb14b0efb9c61ae334612587d76c92f7ddd2ed78" - "a86830cfb4715a02908a6bc917d8b262349d19427c58b0d26be9dd105e819a422b738bd86a0f69f41d668fb6d33de4fb784af5e42d3168" - "ff5fba845faf39d5e65cc388bafb6af671"; -const char RSA_4096_OAEPSHA512_KEY[] = - "0100000000100000000200000002000000020000b84a40ff88dc4d56d93df76a10bbcc0e6ea27a3256cfbbb2b6f87bb9735752e7a51893" - "5d1e8d40777736854204be4a273e76378653178e5201a82ea19e46b59634a424fc6968eaecb76dbe53164a8ef6b822193ec6dd6a7d98c9" - "ea5dd3aae031c854347c5a883b18baf6541b330ed09947adc4ce8974c9534bf572d4b73160491add3d312afbd2a249685c00b995262349" - "dd6ea374b91403be3b008338b7e9fee6f14dff5bbb57b1414a1b912858bdda0cffb2dc0f1a543882ad0b08a95aabb7f4174ea9fa487e1d" - "ac6bd3a531d5ecacae1252e0b0e8ea40d0aa9c691db86df1dfc2c01afaf41ac7e624e6384d0d4bb603f8b19eccf80de9125b868ced158f" - "56712b3b5ffbb5d981e1eca28bc6ac81f1a04afc41032a8891fc5d3d25b86511f6d80137512b9d5e04521e3eacbd60c5047cd7c9d009ab" - "4fd4657b41f28a8f0cb51c73fd89a6eeff0c031c273750c147f12806766791c9cd4beefd71765ce74f5fdf0689ae2ef04fe34931078484" - "04ae44c01f5ddfdc2166ba9037862e132f01274800760879cb23fa4395ae0e9c5380d925d3fcde1782b754f197bdea13eebeed3846eb33" - "5145bd67baf2c10f6379c0321f2abab2e33661c153f4c08eb3eab0897372f43b4cd4dbd4d9dd9487705f4a7cdff310b3c7df5d7d144061" - "40b8a915f569bcdd83b87e8c7638d80d46421b41d8507e4e76ae6ad307fb90fe58cc62d0bf000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000121" - "a31bfe0842fdb2ce702b0aa70740159a47f9b9da728c35f083a6419135ed21eed66f7f5da6369017a851e65ceb46a9a712f8cb81bb18f5" - "0aec61a68a3729c9c2cdfb1a3f3b313607bcf632402d57aedca90ca692b1b3503d650d6c16c867a76e8340193a8507145a7bbf9a3f5582" - "e99755b648647a768cc79e8359241ed50e42e302da4898323800e21578e466bed14e1826ab9b107500c1e60f0fe4785d33737fb3d6da2d" - "75b21ad2a5f976bdcbd952ea11016d9846ab11def7d69ae2bbd915aa73673f11a0435647501824e281127bab48894e8114d0c3c5804b07" - "6bb455a39bee687e49b3e1acb62b77374927fa8efb03a09294ec25107eb82e5ccfc49b98a4c5492c45723b2054454726771e555c105994" - "5d3c1ee5b03bc514d44da961420f4c82b5e6fcdd8849b2395bc9fa1487c0a7381ce651806eb384e90445a8d9e08680d518673bbccc096c" - "9eb232fed9d5eecc7edb09e09ed63884c666c8b9ff65b11fcccae817b993830b4766713250c175fd6d5ed5d18a8c6555583c9665a9e701" - "f0a55725824478bf3a3ec794fa2992afa2cce454c2c9a861afd9cd83dbb66e55aff4e4d5728a2b22a319b39c4df3a3cdeb8d71062d0215" - "12608805239e96d25562445fc30b894890dedc92c8d456029a2d382077956a0f4335c95b06758f2e245725b37c95da5ac1ec3ff4a70ae0" - "3f069a7a11e27ad124aefabc32947761"; -const char RSA_2048_OAEP_KEY[] = - "0100000000080000000100000001000000010000c9354edd8b70a5f187bd3576b08cd52ef54468d027d061e45dca25e0526cc89b4bcbbe" - "1f70ee581a2834c9123b08cc28cfef131d7f8ae5ec5f22dd282cfafe922121da0bf578826a09c13cb5bb6500881a5f245d07ce87ccb670" - "0b5d91cab6d1d591b43558d62da7257c7d63accb6c1f804cc8772370d67d32c99911e33d0b62d186f068ec655c63759944fa8500722835" - "a5ffa35c0199ecac1a304a5ad5eb73cfe031711a3a4928157f9a9494a5c3f3b536be7d11763dd5af26e0ae3cb420d3fa3b6f587cf79faf" - "8ff31bf90304c554d1ab4b2db23a4f0c85a2cc793dc31c31ee21b436093900db2b6636e11bdb0f0fe9fff003d3a4486458027c13098eaf" - "99000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000010001100f583728bd1a11b842eaf4894d046b161a" - "9abf1a9e7061d8f69ca5560ee6c8367991b852bc437dfafd939b07e940da7516611136aff080386bc0f946f5d5c1f6310c856dd76b9969" - "23ea639b0c89c953498ace7e240704d8ff02793a7cd2b0d6fa254728cb17a3c2c33802efb4e0f176bd2a3710361e78a9c81b96a8eba36f" - "e0821a44f82e88e0028ce3aae7f17b295b53fba3b600a358a8321cf80274da7eec5778a2f11e6ec3fd2b110918e15c3a5da5832ef7651c" - "41a160d15679f4ea3bff56bd505f153e013e26a1475370606ddd05e36b76d7cde176eb62af1a48aae3237b86acb0a8c0ceee45a6ca1318" - "6b712e72116fb303775a0a4d8365bf4e35f1"; -const char RSA_3072_OAEP_KEY[] = - "01000000000c0000800100008001000080010000c0d7a1b9eae690d22741b0bad5e6abdb786a201cbb01154f1364fd8b5fc23a09621bca" - "d8b997b32ad0120ee18c662a478313c3a5926151575944241e8ee464fa2fe60c79a324cbfef988275afb009c4aa05935da7a265cc415f7" - "212c9a6a92e2e6d75d621742ef8a2ca468aa5481560b8cd6d346b17f1960cafd2b815949f006613e9b0690c61b5ab83cb3ed746cda04e7" - "565f58a888136a631914c28f9f90851ae1653a9f1f2a60215833110e91ee6c226b97ae5d4ff104eecced33ffd916caa2a84877f58db389" - "3f8e846ee288a751863d867f80e7fc492f1d6da9aa0c60dc1774b343a899d2ea6688b81be72c12c3a79698ccb488c8a96342aa8ade6d15" - "46285d8e5fb35c41910584e9732c2756c40798f413331215814d283f6b7f67f3424f11d5da5cc4b63e163b23f9970c03bc24b924422536" - "021532590a5dbce0a0cff8e7052db4529e7b0205995d1bce29ab4f5ed9840985a57fd60144464c28f22a9bcc8f21b009a69b35f65f0343" - "5dd584b123167d6767226150656ac3c38917ab000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000001000187655eb9a881e5e0878b89c84472c6eb3b2a580d9406f8ad2292dfa9c1bc1eff8390bbe55a" - "b97624731e9ab025e17d81e438363fc3fcec1d86215fb2cce4f338edf47981d5d7fa1ab59cb0f5221295a997d7cb05f0898acc6a17af85" - "1f8e003fab903e92a67e6aacfb171c1dab637bc4744848e2f3b0a762dc62d0eeea800d348d86655640c3b76504c22a1a688a1cb120b3f6" - "11cb926eff5d40b8e0b9f27087e40da90375c16e013ca82e82a55634ae5ba46b4513631378412a44c923b38a59d5af20f66690f0d34813" - "ebafdae3968685390b9db7e8482573df5804b6191e0b32c85644f998de27cd58d6b0151a2645d5d309262c63f033000510528f4efeaa8f" - "ba78a85ba2b95d6ae78c2b29c26f0eb2485aacf275b0e7bd0cdf9992b3debcbabd3a7d74e9b50bc8d45223b668d61ff092276679de789b" - "397501599da8e34cdffc40f771929eaf49579d29a3f6bd03b27490aa195d4273ca3248af236ede466badaf076af2960585d997678417b6" - "d00c49460d173a5e5014712099829385d1"; -const char RSA_4096_OAEP_KEY[] = - "0100000000100000000200000002000000020000cd7af64a4ce004dbfadb758f6d6c5fbc9640e00bc40e8ba08292c2a4c8b3b22d08c547" - "3eaa5083b4dd45bda9c5ce2c86789a7c2db787da6a3ae56736c18d025b6ef1b3a483cc25448de67956b94c390c03f44231939d9dff4985" - "e707dac520b00dcf18b6ae18e16c64f2f169945be2f98df16098e3e8ef3491cf310975a8e1a1e5ed96fc132d7e17ce84b9f4e6c2d842b0" - "739f515f0fe0d8c76ce7da95e4db26e048c3d7b911ef6489d66837f2f9fd8d1812a8417f611cdfd44c2bc5fa4f1f92a2eaee6a08d53189" - "91ad7d1d8e146210308bf456862fb691045443da3e2a92cc611ddb7a08f3f40803cfa3e6cf9abf8188fde526d5fc9c664f424dd5b17366" - "143718f2f6efffcbf42f495d1992db9728c38e993b43d4f191e48374b6c4e7116ecaaf63b5016207fa48407df7394b14a3744ab4a825d5" - "b9dede3e4d1271b2ffc2be70594f689a4695ca97609a3341bfb12e8386ad8deb5d9c95c6fad3f5448390ef5db2cd52a4d709276d6516f3" - "33611e9136d1f2de02927aa404f7c4d755dfe37d44ea9c8eb0a911ce25a7ae4fdd5dd38d1610295692f6ab7d7099913044ff7e348d25cc" - "cbe0e0e34e6fe5f4d1984b4070be9e5e855f58477fa49bf804f6b6136dfa60a8a318d11e031fddff42ec0b9f5243ab5bc3e771a17e3a5a" - "648f7d618d108a4b12d4bee7ae6a2ee43f9226e6878a3dd33ec2d3b981b0d22c7b1ea123f9000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" - "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100014b" - "4117668ad518b2802353e0dd906d57a227cc6642bd99018610bddc9fecbffaa255ae0c13503d8c45e5bedaa8a923c173f61038a618c933" - "52b2a5a4762a708c900b5161952b7512b06d924ee2ba39c25ec85c5dcfd450032928333ebb2eab140f5aa390741e84a0b030119e3b4993" - "cd15e12b219386c1e49cea26e9720011f2bb44d2a12b5ce3eb502567fd7b6e2cc9efd9c8a5828d4c29d88fd83243e77723bbccaa7d1d38" - "a65649ed0e6a3f40b34db35d51e5fb02d4125dac2ff3e802866babe322c20ece15c06e6bfd808f82838fae57f37aa4d660a4a7d33cae77" - "4a1c4d61dc0f7f983bd04a072b4ab9c39ac73c67b1a4f51e35d009e049463c572b0e5cfcac332a782608d39c7bd4c3be513aefa9bba8c2" - "2df88c40b3635d3e9dbbeaa4ced0e7f53a1599f8b9f3a164e7aa4954141bec6bd0a5052fccffab1ab53c941f9d04bab5eee41eeda05152" - "aad1ac2c39f8d1ad9fe3804dba684c981776ae1c9fc2dad2549708d158cf6350f0c4da940c69610decbfda5398580ea491424aabbd0f62" - "d14646fddd5509005d3474a506d6b919e133596422f60190b10b807b7992d57ae5dca530e30a064553e5cc22a8b98616b56425716eaac6" - "bd700a3e127011894493a86c2c483c04e6f22efb4049015cebd96bcaa36303b41cc7eabdd205efd99c1841c7f1cf6fddd27c167cadebba" - "d8989837da29f0e5c7f1047c222f79c9"; -} // namespace -class HksCryptoHalRsaOaepDecrypt : public HksCryptoHalCommon, public testing::Test {}; +struct TestCaseParams { + HksUsageSpec usageSpec; + std::string keyData; + std::string hexData; -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_013 - * @tc.name : HksCryptoHalRsaOaepDecrypt_013 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_013, Function | SmallTest | Level1) -{ - int32_t ret; + HksErrorCode decryptResult; +}; - const char *keyData = +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_013_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA1, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" - "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "070bd81030f33310b12f3a83894c16ab23ebc6d9843a71988807874a465eb29f06042a5e9b27f16e998815e1bf8" + "a5f55b48750632202693fde21264c21dedd33", - HksUsageSpec usageSpec = { + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_014_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "070bd81030f33310b12f3a83894c16ab23ebc6d9843a71988807874a465eb29f06042a5e9b27f16e998815e1bf8" - "a5f55b48750632202693fde21264c21dedd33"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_014 - * @tc.name : HksCryptoHalRsaOaepDecrypt_014 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_014, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000030000600000006000000060000000eadcc37762c4a0c4cd358de290f2efedf39503a1833e4082aef44cb564ff47d4feaee5" "f145b3711cd9abf944e0586bc083dd2c7dde4fc8f7d9a69d4fc5a8aef527c82d02fd30eb33a1791db30011733d60ef3110bd769f385f10" "b071ae552dbd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001158f2e62472ec593" "4b431f432d0b1ffb37e0f5f45d97d95425bb474f5f760fa1fdbf105c95896358c2a286bf4bd8d20b2d0b0880ff0193bcf0e625a9dbe330" - "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "6ea4534c0d7e83b657684194501574a554f76cbe29ce5953e1d92b479b4d1f8201", + .hexData = + "35249280c4a155024e0f64c0c26ab980d1ddd9fa05ee8c4ad8122f70647c0c608b63c3efe68dde3e07cacd89398ec1660f858bfb1082e6" + "ed82ce54c14a7c6927a229c0b619d0e909c09daab2dae24a809139496217307fb02a5d4dea9b2e0074", + + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_015_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = - "35249280c4a155024e0f64c0c26ab980d1ddd9fa05ee8c4ad8122f70647c0c608b63c3efe68dde3e07cacd89398ec1660f858bfb1082e6" - "ed82ce54c14a7c6927a229c0b619d0e909c09daab2dae24a809139496217307fb02a5d4dea9b2e0074"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_015 - * @tc.name : HksCryptoHalRsaOaepDecrypt_015 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_015, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000040000800000008000000080000000d10cdba0a029d15254e1b98a1ab3fe28387017976d817ed229a88e521037451768a681" "bd6b8944d1efc6be41913da3dc8cf42cae0d0b449e2cec4df0537b1702cd9a79b8394175c0474e96fdc7d26616c268059c4d01bb6ffa70" "c12fa591e40093d988fe0c1d76df2d5999827cb12e7b287d537d477a7a8dae6ce9e6a1c2577d0000000000000000000000000000000000" @@ -561,169 +95,133 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_015, Function | "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" "010b443221f9ffc6f434f6e554f81373431fa78addf25ce444d751ea39a9fe108f2e68aadd568a53572d20fce7f3b7eab8dc2fdca894b3" "62c3539078b2d70cef3472861416697b8908bd3c7263a6873b3baada43817202bb5b90e417af0e3ba8c1fefa011592604c2c9066e12265" - "5b83ef84097f2112e64d11193da5dfcfbf9a51"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA1, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; - - const char *hexData = "752b367cad05c09718da9077ada4062a3aca68a63c92af640cdfcb6c409cd857df9092bfd1dd14f894fde120434" - "f2007e67d10acf835c4767be6b596840faf88a706e95f085d63b46694a5ed492ca36c251636af3839eaba1a7714" - "d796a686cd94afdb96893f04fe276d681afe036708dcf3a8bd7516255dd8042eb9517e9584"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_016 - * @tc.name : HksCryptoHalRsaOaepDecrypt_016 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_016, Function | SmallTest | Level1) -{ - int32_t ret; + "5b83ef84097f2112e64d11193da5dfcfbf9a51", + .hexData = "752b367cad05c09718da9077ada4062a3aca68a63c92af640cdfcb6c409cd857df9092bfd1dd14f894fde120434" + "f2007e67d10acf835c4767be6b596840faf88a706e95f085d63b46694a5ed492ca36c251636af3839eaba1a7714" + "d796a686cd94afdb96893f04fe276d681afe036708dcf3a8bd7516255dd8042eb9517e9584", - uint32_t keyLen = strlen(RSA_2048_OAEPSHA1_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_OAEPSHA1_KEY[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_016_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000080000000100000001000000010000c594f464bc7852f61e96a56ffab6d1ee5cc5552e51ce5426b17b8fb50cefadecb0ef2e" + "9402906b9460f2dc527188a346e964acdc3357c2dcc56be8247243350cd9dc122dac3f37f4d22870e9b6d5524d43fadf5cb3a5386ebc11" + "4fc830faa624155526fc893bf7848451827c68c3610932a7a97a55c371340b86b4ba1aeacdc0185a7ac78511947bec87bbbfe011baa45b" + "19d7f7eb0accc77502f26ebb0d4797b3cf1a32116f9cd9f0ad4977d2881cb61d0439099c77e3e59aeb4386ca545cf534453c55d7b548e3" + "de6cc513374cbe312eb6564d476859307dd47498df59dfeaade0a8339754fb3a192cd64bad563c861b505d05b54a6254903ebfdfc6beb7" + "79000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000010001691598061bd7430873ac5bc0faef51281d5f" + "36b6b3fbb0f6035f5c4746e212f6d803de1a0a6315548d5b9da29b8fb887768a7d0580a9249296cd95620d0381ab9c1357f7c2acbcee10" + "f841558c5058bd8f725669cf8208499cecf829d922f64a2aae6755d90773d59f2a5ae4203409e00278f9c27eeabbc29a7ec29058d0992c" + "a911b57a2af8a582caaa3add2aec200127e95e9032a8a4c546fab425148dc2c72ff487ad05bf0dcd278024e74d0e010f5aab57eaa5dc8d" + "ffc4e049cc6e2b34d50db7e73f0f4c78e887a0b59f2ce34117ed605379c0b28a096c2c38282af0048df55dbf771cc57e327e8008e86723" + "adf95c1f761b56c8ddf2e78e532861cef681", + .hexData = "c303489c1204761cf6e3ea1d4ebbdd77933dce5acff16594564a9b1c41a5690a04777814c531ff8f0a0112182b0f96c627e3756d4b2756" "d7d1f8a2ec8c7cba4e0cb29d9cb8edf343e5633715297a882f4a864e4543b30063018ce01358639fdd9ad452152fd4d938f9e680b23e7b" "27fa85a23c027c7ca95498c3ee2f8ac0bbeec11c0c8455584f2f583027054b39b92326f018d2d68093b99cf741a2985e8af712548eff72" "5b5c707172458ed73b6fcc98143fd1bf6ede2885a9ebe10e76b215d4554d6cc9b04cc10c76b6a3c4f8d0dd1b67fb439b9dcf4fa2cc59b3" - "786a4f57f328645d20d8a3da2e301f42783f453ae93c622173d643516c8484d024d6b5d8"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_017 - * @tc.name : HksCryptoHalRsaOaepDecrypt_017 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_017, Function | SmallTest | Level1) -{ - int32_t ret; + "786a4f57f328645d20d8a3da2e301f42783f453ae93c622173d643516c8484d024d6b5d8", - uint32_t keyLen = strlen(RSA_3072_OAEPSHA1_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA1_KEY[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_017_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "01000000000c0000800100008001000080010000c50e4fe8739a73a3627e504ffd323bb95057417d2b23fac0939c6e3c43c19450b38733" + "19275612866f0e8d349585c17bffa9c13389975916f2235161fca6a655b4c0a3c833789a18a9add01f837da762b5acdf29f296324b4d5f" + "7f586f900566d949f4784b935503b4105e2c6e83d43d6d17e07545eac427be17f0fd7b08fab210f38bfb405ca524877d5c039505a0a9d7" + "c2e24e9367a8a13e2fb9e3e1dd7b72936737b0590ce3cc9262284ed041c2b362ed3b617bf879256e69be4357c027dc66d5afc0a4d35a2d" + "cc6b42344bf55b90985aea8d2604af1ad404fa8dd9014c21da00a2587c82f97045b8be3593a41d71307f5b3295964257ab8d7ab8521b47" + "29dba792af69655296577ca175d974e64ed33881c905649b8a6bbb13ac1cb1cafc6ad61af81d3a0813eb1107d0d953607a1e99657de527" + "c108ce22c06f8585751f071efd87e7e874e01c17714ce73c2b619594119030f54f9c88158b8d64ffdbde582c3340898c18762458bec67b" + "a306aca31268accd72a4382c6e06b35a01f673000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100012ce1e0a3724938937b288804600824004663496048062ee3d3fb2a4481ae42a8caeb3d613a" + "4b6976c32ece4caecdc34f09e15146faccc516ebd9cd7c82fe361e8947e346032b31f5f217cbb291d179e18abdb02aaebd35015fc3238f" + "3201dca91b4eb3e6fe57b5625d8de8d537eac0d9a8d26a666ba158423112e4e9e72f19629b67cd7751a6885ab49d81eab2f3902f7f1c3d" + "4d665792d9feff01d8fca5e4ab2915b6626d35f960abeabd818dff9c681d5d294c3fdf4d409050776c813d1c16b9ae28a78057a4a47e77" + "c62071a0da7d8cef186a98f2c95b16394689534726d18fa8b0526c40d64bb13f579532fc56e9ff2fdf95f0df3ab8493264ed098cb57e8c" + "fe9cbce24a5bdbea355ede53246798c79599d7aee1ac380ed8ee77f08276c617fee8a8989c116407e8d7a481ff77ef32f7405b5736b36a" + "593925cf15c3da1965f84eb4153a7d557a790a869fb99290dca0b4d6a97bc0ed32fa41eba3a27b9379e3f2b140e7d1e0a315af6561c5ff" + "1c894ad34cb998b6eeaeec5d3785bddfc1", + .hexData = "444665d129abd103992a5953066d4e7a6bbe9f6132d2a783db39c665980b5b89c9bb06de04fabf8aa1d7d2a5ef34d55a336200632a933f" "73f3f9f84ca1cfbb6e69986c128919dcacb16f741b2e0c90562ed3f410e4419411d49650b73be9e910705cb69824286640debf3be88e5a" "c5cc300b38575933df66b9c51907e2e997b531a486bd320becba1992fad8b099f6b110c125c3559431f45cf0ad9ede5c33087e4b464905" "8a9e87bddc647eb02bdc39fb86f5498dbd3a317bbf29d02460a0991f9cfd615f0efffc1a66e5d48af9aeba2702ec7c3c0dd48a1987f333" "5c06208ebdf0c0817604137f9c67718faf301059a2be8da7ac43663410e44362e28fcc0f17de1af251c7145c944c1e4bf29d7989d5805b" "f971ebf021ca7e139f0a1f946636b17e2638f3b59e04ff613c20fe58f9b07bf2c039a27aaf3da4cc788effbc4214f7d3034e1f32ac0361" - "e5a7f88871be506b43aa5ed24e42ffdf3174e89d3a3e7337389d3e017ee76005154afae1230993ed1dda61194ef4fb9ade757d5b27af"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_018 - * @tc.name : HksCryptoHalRsaOaepDecrypt_018 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-OAEP_SHA1 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_018, Function | SmallTest | Level1) -{ - int32_t ret; + "e5a7f88871be506b43aa5ed24e42ffdf3174e89d3a3e7337389d3e017ee76005154afae1230993ed1dda61194ef4fb9ade757d5b27af", - uint32_t keyLen = strlen(RSA_4096_OAEPSHA1_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA1_KEY[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_018_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA1, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000100000000200000002000000020000b3166774620460ff0b4fd912c441a184527d8b6bcf1d4fe22791bd0a79b9cdb4afc944" + "532e948aa190ec27869df84384f0921abf036181369db2ec71011f3f2ea1b1a0f8521cdb75a47e1051e68d3220248b9e68303780247fba" + "99610d7309a99087c6da95a0f3bd5abdf703693bc7285a0a30944e132015370f9d263f44b8b2d05ed32470096eb6c7309e6c62d74cf99e" + "72ee94e8e1bbbcc902935762c6a5e3297e4766fc49867e7768f40902d87a219d92c196caa030a206ab75c02a4fbc4d0803d082fd328613" + "9315489f52b591caff2827d70d8839f47fb4195dc6036f3718987b56e6c772a30694cf983671ad6b93e1ec99ff94125a6268b1e556671d" + "11d41eeaec4c5e642534243dc5f4edd64190dcab9497298d8101ed7c3a97b4f28c892cdb2e3adc67bca83862429d82e8f6c40b72d7dc39" + "1b214c09da284a7aeed2a21914dd0aa3ffa0c97800b8c37198e92a5ed1c12788c9313d3bddf5436cf17c1e481e7613fe8a04cb8e5c14f9" + "8c450f4df4a3f77e548615adc6face54baf5f60a140759ad341aafe0187d9f05745f094b547dc4bb3ad5b2be64dc10e000e555c7a09282" + "e7ceeb8d99e1fbc64e57409f644fe5e877735695222347ce556fa340188ed74df9ebb26f7205206a94b9eba96da988e13ad273b931a9f7" + "6e501f371e789cb2a1249056076e50091949bb9ace7af104cd9db3e03d832a4c3e6fdb9c87000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000170" + "d46ab5ae9367b1082574741865e926fef9cdff4c6c014a50f7c70c7488958b833ce0e92f6db2b1fc266cf8a94a22effcc970446c12e05f" + "d29749d4208ad939bdf1b5a2fdc8e49387e14cd2ecd8847e2fc82f33213db664487cfde96199daba942e97205c291da76d26461c460ebd" + "7934d13aae154a836a1a58a1ffd8d8a92d2f8eaea4445a0d00e71a4095b4e844bcf8111d33804dc80436f8827009f171ce5ef40a745dfa" + "ccdb9ccbe9044c60ab01c6cf115cb9a8973b5dcc64d17f56e121ff2cb80fef0a07e30945dd8d5384c5a8097df92bca80cb52b9aa7458da" + "4a8ba540bfc0e58d5c976312e06ab2518ae961dfb7f56348dcb77b6e88db9bcc06070f871c5f38d10e16c686e51a78a7d54a78e7ba0d5f" + "a5c42c4a401529890f5f697ae567a0e5583f49e73f2ee735dba5d0b15df3f0195a48de70120eead966126f161bb57d770cff988500ed1e" + "49739298692a55764756eb3930ddcd035f36f121b242d21bb4088bf176a3a98045e25ef9347d2a2438fedb024765d80b7a6b4d5b0edff1" + "dc96854afae97c3b6bb40793f78e93972a8080b87934ef9e014087ad5c794dfd6313cef45d72d9be592846a5c4414b2570de994b467db7" + "8f068d0886fc1d67a36f80f556b5913a55da31fc193718e74dc3275c224875eecad8a353183244c4c73c2bb6b96a5ce84c5c8992b43eb7" + "2ed71af821a658f473f0a3a283f40d41", + .hexData = "193b8cc1eb7736b40ceb90c48a184a2bd7b02759e0ba6f167dfeccdbc09e40ab1ab7e7940b073951892696e5dea1325da7662d61e4b888" "b395067dbe3db7e2fae21c8da725b841e7d05306a44a69736d4003ee18eb3013e9df01b78205e9b8d789f670f51d7e425c0f63355c615f" "460d066d52fc747eaa23f8ec411bd22ea75db5236035b2805d9e356cb8f694a4788dc549db357cb7e914f55ebd9d1b76f272544adb71e6" @@ -733,139 +231,64 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_018, Function | "45b87374f04e73214e4c6ce61e4d77643e1fd8c13ac0e1b93e55ad2b574e9185b0f490dc0cf8858125b505edc330f91bd44bc14f74bdb6" "66e6df9d26bf4c45e414ba569461f3f53915a5b80edb59254e6b786fb24728b4c08180bd912b037a20ac9a4d795121eb7bdbf38cd36aff" "4adc1c693b51ef6d5d85395ba16f35eca51317c9ecbe67b7b583cb8006c79f51e20efc2c2187b529aef5fdd7cfbd2c9cb1798f43883e83" - "70bf2e4c27a89d718536c06e449b934b41"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; + "70bf2e4c27a89d718536c06e449b934b41", - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_019 - * @tc.name : HksCryptoHalRsaOaepDecrypt_019 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_019, Function | SmallTest | Level1) -{ - int32_t ret; + .decryptResult = HKS_SUCCESS, +}; - const char *keyData = +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_019_PARAMS = { + .usageSpec = { + .algType = HKS_ALG_RSA, + .mode = HKS_MODE_ECB, + .padding = HKS_PADDING_OAEP, + .digest = HKS_DIGEST_SHA224, + .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, + .algParam = nullptr, + }, + .keyData = "0100000000020000400000004000000040000000b9d0e8e1e1e33cd6eaf71c9a4fb26045d651ac7b7a32984b5ca5bafd6d34d6928256de" "c0e3ffdf2712185b50c5939077eb460da307125470b52bbcb0a58455eb0000000000000000000000000000000000000000000000000000" "000000000000000000000000000000000000000000000000000000000000000000000001000155e461a1f85ea802d87dfdb4bede3f6e48" - "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "d15c1f7faedf8306827d5b241de688ec7fef8839a217a03360771ae67ff5183fce0ad19b9c15232db782d9b9a607d1", + .hexData = "aa7b5d9919b61a4d1a7e7b3651c17a758e995ec9583e9d2b5ef4121b45d8f9dec009fc03b19e4527105ee1d0cbd" + "1b3bd66123c12899f1e425ea63e69958e6dc5", + + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_020_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = "aa7b5d9919b61a4d1a7e7b3651c17a758e995ec9583e9d2b5ef4121b45d8f9dec009fc03b19e4527105ee1d0cbd" - "1b3bd66123c12899f1e425ea63e69958e6dc5"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_020 - * @tc.name : HksCryptoHalRsaOaepDecrypt_020 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-768-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_020, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000030000600000006000000060000000ac66380f18d9dab2188de40e6bb622e2da123e08add16b7c5dc260dfbfe7432c390698" "e3bf34e7e237c0777e4bb10a29ad8ce41172cad65dfcadf25c8dbf9b0e9fcd62d5a4b7967199151aaf97df9eaffd0a2f96cf324c2a6001" "7f5f29d59dc100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100017ac81636d2591dc3" "676f6eb3c28ca64df047bbbc8ca6b0a99351039377662a560d8b204a5b7c3f85c27525e561dd05c1bbdb5bc9bddede40e55397fc15034d" - "d30c4309779e0437e0c14191e04829be3d20448bcdc236eabd23ee05a8d76c0001"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } + "d30c4309779e0437e0c14191e04829be3d20448bcdc236eabd23ee05a8d76c0001", + .hexData = + "8e5129736a8e1986fcdfadd0393f8aabe080823a7b4275d0dfa4d9fa32b9e05720d957130acf4c8cd512688d447b8f84cfe7f1b4cb4371" + "e2f988ee2774b280de4461f40467d2e03e86389547b5066e43f81e2da8e5cfbd9aa0c2f16fdfb618dd", - HksUsageSpec usageSpec = { + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_021_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = - "8e5129736a8e1986fcdfadd0393f8aabe080823a7b4275d0dfa4d9fa32b9e05720d957130acf4c8cd512688d447b8f84cfe7f1b4cb4371" - "e2f988ee2774b280de4461f40467d2e03e86389547b5066e43f81e2da8e5cfbd9aa0c2f16fdfb618dd"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_021 - * @tc.name : HksCryptoHalRsaOaepDecrypt_021 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-1024-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_021, Function | SmallTest | Level1) -{ - int32_t ret; - - const char *keyData = + }, + .keyData = "0100000000040000800000008000000080000000cd1a15f15683bc8bb38041d407aa1499bffa2831f94f61ba607a37da356a664e0af5ea" "01a43052b1b93221208764c02df86d69ee2475192b0bee0dd08246a3a927df959e3e2ca68558e3e8f82c1fbc231524f3d78bd2ad1141db" "4dbf5800a031f254a9f5eca58169bb3daa787707863d0f42a0a868c1cf882c995965cb4317dd0000000000000000000000000000000000" @@ -873,311 +296,204 @@ HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_021, Function | "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" "014145f0ffca71c87a8958e31a508a1f5e430ba0e92e97c5d963c4e1ab8f5e5a4ab2104b35d484107d411c2410cf261047510db92db1ea" "9664edba0829789c748ed96740a56894f7f085ce43761b81e00738337061bb7f7fd27318c558f4deff8160c071c7c91c47a3e01950198c" - "ff3985125a1ae69abddb80834bafc33944edc1"; - uint32_t keyLen = strlen(keyData) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&keyData[2 * ii]); - } - - HksUsageSpec usageSpec = { - .algType = HKS_ALG_RSA, - .mode = HKS_MODE_ECB, - .padding = HKS_PADDING_OAEP, - .digest = HKS_DIGEST_SHA224, - .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, - .algParam = nullptr, - }; + "ff3985125a1ae69abddb80834bafc33944edc1", + .hexData = "7d18be21fa944e51759c94e1b276d5051059e2b759a12090c6d22b264d46f00e9d52d3ddd5878c381c00c675ddf" + "e08f48dc47b6c8e01a759dfc2ead5bdc72afcec8f8cd939dd256b619cbb98b5cd3e387f048b7ccef09c5c1c8004" + "0e59760f64300ef08739e22fa7e272fa3c5ced217b6a7371b435cf9c169ecc1a1d551fc05e", - const char *hexData = "7d18be21fa944e51759c94e1b276d5051059e2b759a12090c6d22b264d46f00e9d52d3ddd5878c381c00c675ddf" - "e08f48dc47b6c8e01a759dfc2ead5bdc72afcec8f8cd939dd256b619cbb98b5cd3e387f048b7ccef09c5c1c8004" - "0e59760f64300ef08739e22fa7e272fa3c5ced217b6a7371b435cf9c169ecc1a1d551fc05e"; - uint32_t dataLen = strlen(hexData) / 2; + .decryptResult = HKS_SUCCESS, +}; - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_022 - * @tc.name : HksCryptoHalRsaOaepDecrypt_022 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-2048-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_022, Function | SmallTest | Level1) -{ - int32_t ret; - - uint32_t keyLen = strlen(RSA_2048_OAEPSHA224_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_2048_OAEPSHA224_KEY[2 * ii]); - } - - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_022_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "0100000000080000000100000001000000010000d44c2eba9c805a2e00397ba68b54ded3d626b02b93d72664f97e023ecf5d4974388aac" + "ab0983529acc1302beef7975cf9db43a4a422b258bc3db75fdba50fd67bd009a44a248b712638589c6d5115aeb8b320c04401400c3a0d8" + "6684337937ff2259330c06dfbd652497fbdf5722dcc8a4d583f59ad1a02eca4a964516a23a06c4398d4edd2c977e7b85d41f303f62bfb9" + "3ff65e9e837e8d3c6f1c9c9d067a0df7c36a0c196349d2cfc1d82c5daa60935171e42754447ce60328abbcbba6078c39ccda078cf88adc" + "1dbfbc645a401fe386b57b5edc94d5bc8fc7e2c3cac6608fe8d91e69ea9fb17f6b7b42ae794fbe82e12cfa4ce60a11de5e83c315b902d5" + "c9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "000000000000000000000000000000000000000000000000000000000000000000000100014aba8a545bd47e69e4e0571b37be67355013" + "8c3dbaaba83330f35f1cf6e7527cdb8e4cdb63dcdb0dec39e0e48eed454010b629328c7a1d9c461411437ffb144818ea86631470de2855" + "e9e2a69fc79d267e77de6cfc954df38ec1bdcc59461924f0d54f37b38fbc5e46f44ccfc01f60722c3b9058bae7812817430c0443c45501" + "fa69778115a748a79b89d1e99c7791516a2f7d19114cbbd4ed7827b51ff8caee4dee84f16ed0a1b497513be6d563fc5ee7d0891c523e8c" + "0c0be002f7edc638607ba45647166342b004d1cc7a31a3492d8980b9a3f2151a4aa2cd8bdac7b1652d791e6915730bc9de98ac1a3b5fd8" + "2c26ae2da515146886c78090a7aa8c31ecf5", + .hexData = "a3f9244077328f00ed6921234d6d9ede1c1d580a8ba7a5f3748880d29011e50e26e1f84106674d07e20c4ea5ff0d6821979f01d86f4a16" "4e5cc3c3af9fc8bb627beada5686f3281b105f2c5da0453cd75f5ec13d1543dd84dc7a14da3aeb55dca29aa0466f78d0d8e6e223ff5534" "ad1d638f7f4cab4d8fc3a8b68a83df50102302f1445bf5c7782fc787b6e95ad21bb4dd3b2460dd17447296fa898af7e5b8ef99b43d2eb5" "9e7b1142cce5e9bbb2181a3a5241572c194df23f2f4242d825bf6ab6d943db161ec879566d0c3b845c57586109a9f408e4ccb6f79ecc71" - "2c18dad3476d283fac34d6513e34e01f9688afe2fca84e00976fd624292aa128b6518dbd"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} - -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_023 - * @tc.name : HksCryptoHalRsaOaepDecrypt_023 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-3072-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_023, Function | SmallTest | Level1) -{ - int32_t ret; + "2c18dad3476d283fac34d6513e34e01f9688afe2fca84e00976fd624292aa128b6518dbd", - uint32_t keyLen = strlen(RSA_3072_OAEPSHA224_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_3072_OAEPSHA224_KEY[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_023_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = + }, + .keyData = + "01000000000c0000800100008001000080010000dc3d6c0fb6da1679390202196baa6a999f217a7ed8ba8a3d309bcdff755094dd09bc41" + "77ea6ed014ee412051b2c02f851f32e4400c894ec6da6b510d613536c32f2dbce41d4b9196c24ade4edbde812e8eb2a774bad179c7bc4b" + "aa338fa2cd67d5e6b868b042b7fc0120fcf2e8e104a3dbc35c250fc91e486565e8928d5d047d0bae93ff09d9351157e5a000073935b09f" + "4bc7e5b25e2287f44ac8daed8e0e5db021359ec22acd2a1d374d82d7ddfbedd7ffe6a09e52fe8d23a751665fd8b36a456fea4d69900a7a" + "623d92c6a28e56d80561e3123a99c49253058177cff12a06c8e4d77563f0367f5ebaa8f5d71750c721fb6a6dee9d28a97c7474692f60f5" + "528f3a1e02234c93fd895e62f40a9c44ed62cf37c52e1c4f582350c6ca7991a6468cf4dd75b556cffb09c6b69c4719d00196f4bbe1dce1" + "204bbc5a673fc81fbac0a8e2fbfc7d4f87ef3e1a501da79226ff984e440731c7a2d8882aafe3d8195dfbcd8c8665e9e1bb334fc9b64ec6" + "b22f38015a9e797b3a509b8efb44541344a64f000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000100019570a40361aa47b7878422528768c21e6d08b56a9ebaac946a883dd60a0f5c834358d6ff7c" + "3626c11d0d59d5b5b98c4502ef704b39766ddaa6584d4e0bd8a4c8fa1949e36b315c9f744482e5f570dc2cf02caf4d987a0ced078a3bf9" + "f28ba05ec5986126bffaf5866c69aad9544562f5a067c5fd6be1a6c7aeede04a98db35f1775cc51537e4878ab61e9c5b888b3c301556c1" + "53cd9cec475deee4ad10a5e47f93c464f2cd8367651d1fea5b4f08542a85f720d179bc8cf6cdeb796342c3f2b0756daf51eda214a3e49e" + "23fa8682ca429d1f5bdb6488baa9595272ceb55517fda0eb723256c50fb151a175d73a117508213b7e6d3be0eac0f6c349b5af0d77f22a" + "5bdc22cdab221cb8e474011122e67d195a00ce9dd821242df8eebde04770527d559370e93b7f8c7e882db778b6255d487d2119acfd81bd" + "0363e27d27486d14df9407e8290916064230a638782b4a1b02582c1841703f88d0555357d9c0a2052d9d6bb7d7e5e1302c466eaa621e4b" + "4c6b42f0a1bf2588695018a295ebd7f031", + .hexData = "5e9f606bffcfb96cd8905ccaf2aef45b6c78bb1ff81907c849fc10cbdafed6309df895697051e5c7ff473d65aaa0fcc79ee7c4b1e5f1cd" "3f8b269230303a5d838e93b9a0f8cf12b8bf459faa0653c7a0f9ca94fad2e789bf89b8515dc9e9e3ff3c4fcf86c426f2557a7467005f28" "ab978c3cc4a06faa102d8fa3ad9299d3891bcf50f926e3722075ff89cfc9061a3ea498e37e8202bcb4eedede8541c1425a4e278fa7a821" "202ebb5e64c7052aae99fce16ae14371fa94614c87a62cd1576e0ddc93faf4af81d84cc65d003fc6eed7a9310005c05f5ce7284be77cce" "dc287da88c9ae840ebbc6ef3abc440f089f93b06da4b7b4122c0b9a6f120ce0167aba1551082d93df8e6edacaf442b200c9ad4d5e6aa50" "9245f955d7b3126e8b7edcd294cb8a8e9c52c660c2059d536b6c8c5f9364d86a45f501b0f944207bcd631f9a6b69e3b508946f539f7fa8" - "0c877b80522d08bb3f41a7a442894567aac96ecb929cb9c1fc5972172845b2859c094836a0b1755b3c8c50e54a51b93b4aa6958d646a"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} + "0c877b80522d08bb3f41a7a442894567aac96ecb929cb9c1fc5972172845b2859c094836a0b1755b3c8c50e54a51b93b4aa6958d646a", -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_024 - * @tc.name : HksCryptoHalRsaOaepDecrypt_024 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-4096-OAEP_SHA224 key. - */ -HWTEST_F(HksCryptoHalRsaOaepDecrypt, HksCryptoHalRsaOaepDecrypt_024, Function | SmallTest | Level1) -{ - int32_t ret; - - uint32_t keyLen = strlen(RSA_4096_OAEPSHA224_KEY) / 2; - HksBlob key = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }; - for (uint32_t ii = 0; ii < keyLen; ii++) { - key.data[ii] = ReadHex((const uint8_t *)&RSA_4096_OAEPSHA224_KEY[2 * ii]); - } + .decryptResult = HKS_SUCCESS, +}; - HksUsageSpec usageSpec = { +const TestCaseParams HKS_CRYPTO_HAL_RSA_OAEP_DECRYPT_024_PARAMS = { + .usageSpec = { .algType = HKS_ALG_RSA, .mode = HKS_MODE_ECB, .padding = HKS_PADDING_OAEP, .digest = HKS_DIGEST_SHA224, .purpose = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT, .algParam = nullptr, - }; - - const char *hexData = - "8687202d898e1a5cef2f34dc0ab0c57f1ac8e9c0b4e1c2b76362a8bfc427dc2cddee16722b748a521bae5a5013f94bbc2587654ab42fa2" - "3d8026c91dfeac05e5adecdc230943a5f4c711cf745f81a852c63823fdbbccf10f5455cec93575d4164a21e07fa9102fb63843aa95f6bc" - "0cc299f4a8e9e2b32163485e893aff386c5d573054c63bd56842111b61323335501f858b5e71a566931f7c6f5ea3db1beb29bbdf095eba" - "b66477b666e7c74fbc3759319fd25f7f584d6bd556cf067313918e8cdfd8b96857b8c1e50ed1a7159e13ef7296352bea25c802ca0a8d22" - "9b96fa66a6c497b7ee5dcb3baf69152050e9c3873e2891c13dea277bfdf5af46f91c406472e96a5e5ffe2f326777c59b9b5926b2db0961" - "cd6764cd3bfc7b09af75ce79a34247bf860a502fde341f6e736adb6579fde5b56f8adae621580a6872ad1493ed21f57dd8b2547e0f52f4" + }, + .keyData = + "0100000000100000000200000002000000020000bd0d9010dd30b0ec8c396744527127508359e0f12aa4b8b09dc20f42040644d4b33f90" + "de38ce815367af5a8cabf18a71732d569bcda767767ae0b61f38108a021d197b2e097e60cad6ff186a3510667a4e19eca53abca79dbc57" + "8e0d30ba42146946c1f5fcd6204e17252be83121554ca68637e85e5534d1f2c943831d9a65de22c70812872ec219cd2ede8c8c3e78a5d5" + "250b3edf4bb4bfd9a9232f2dd2902b61eca43038d354a365dcacc623de3b062207f7807c9d877a603e2c70ae129c5d418fe52f023025d2" + "68b0627c0dbf1488fa078fb187b57c17c86a43116f94622c5ba31c4ca771428fb73c8b9ee7ff21962dad6b2094c83823f413bd8ec23648" + "186c34a2ba9f0d972af78d7882bedd926faffc6944c4d4211888fa4a49ced7f558d30929041d93a8c5d2275e0330909cb201a618f5a747" + "edc459189b7d30426c49a0d10646a10f015f1e418370874ec2ab0304515178c9fb4425b7c4747e6fef0981b8d599cd3c1152ed804a79b8" + "9737a5344848a4b36ccc9a29b7fd58ec854a5457fb9b24f192959050ea793b8f17d27cb8cd809b9b87957889947576137868bb30bd4810" + "c421b6e937fbb554f9345e266cab23623970f94df74a0a6321487fa655933f45a1fdff7252aad1230e518503ca22ff815d6427acdb57df" + "b7480bd4fda526470c7a3187ea980db8b75b486d77844e030821b804f32b56b75994b96a11000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000116" + "9c2ea4b5af83196753de33dfa044d16e442b90ec46b307fc761f19081e2fd13876dbbe9810aa8aed159dc0c137ac15116f54b2619029e1" + "93a49863777312ee59c89860d325d831aa30ec1c97a814798029bd91ad4aaec940a3400bf7cdeee53e0a065c8316a0da760e2e08210819" + "898748fa1ac25d7269c19dac835be10159e5d2e3f64350a64a2badf553ddda02d7e27c01b24d4662a1a748813abd423797d8a852a2a9c9" + "2c90363884395644d7ce4df7a1f42df33126c3a7ebecb604e7ca8772cc38290cd5192b081d5f34cdab890e4e25335845ae47b1e2738efc" + "4744ce854f26ad4c4151729ab995013641df2474e60eafe0db694b737f80e637f801fb25223a924e96341ecd43fde54a977bd668c5a9a3" + "95dfe66562891c211e888e68ec740f05e5cbf3776774689b83453463a226d4dfa263dafee68378af41c5391bea2588f356799578bc5b67" + "e6382f5739a428589429c9fa66bc8a418ed6a353a09f92efecc9029f51eedf9f98134310cc11ec064fb6e5c9266b0aa88d42e8e574f3fd" + "2f3da8e34a310324b42bec03945c67b54915f82eab1936972a2ae42ac1d71f3c552b39a3a62e25b7b38dcab1c4b71b89445dc563a158b8" + "614a5d4c4792e3e9c1e4aad4a854930f63a476441d90422e1a671b0fbbeda2015b189756e421c8e7a6253e354c7e116ed50cb410bdedf5" + "5689eeac4e8eb71c16fc15829b821b21", + .hexData = + "8687202d898e1a5cef2f34dc0ab0c57f1ac8e9c0b4e1c2b76362a8bfc427dc2cddee16722b748a521bae5a5013f94bbc2587654ab42fa2" + "3d8026c91dfeac05e5adecdc230943a5f4c711cf745f81a852c63823fdbbccf10f5455cec93575d4164a21e07fa9102fb63843aa95f6bc" + "0cc299f4a8e9e2b32163485e893aff386c5d573054c63bd56842111b61323335501f858b5e71a566931f7c6f5ea3db1beb29bbdf095eba" + "b66477b666e7c74fbc3759319fd25f7f584d6bd556cf067313918e8cdfd8b96857b8c1e50ed1a7159e13ef7296352bea25c802ca0a8d22" + "9b96fa66a6c497b7ee5dcb3baf69152050e9c3873e2891c13dea277bfdf5af46f91c406472e96a5e5ffe2f326777c59b9b5926b2db0961" + "cd6764cd3bfc7b09af75ce79a34247bf860a502fde341f6e736adb6579fde5b56f8adae621580a6872ad1493ed21f57dd8b2547e0f52f4" "ab21950c8e77a9d15caa5799cf517581f072632acff9309dfd3467ee6e9f3e72b0e9e7cde6dc96d979a8be167337d4689da8d84b46ce53" "14b90ecdb15c84af1b57b906d53bb9d751928a02cae04dc07e752d422c8b91fb9ae26e3c3f034cc488a98719f70146a62fd4999a4716cb" "52ca1212fe0c5fe504fbebe7457253f7993eb5955c440d1d918f873126e6d2c07a613b56137ec4086e9f8dbff10b2333be22203b2e8e48" - "de68a475b9453c38ee89a4ccfd895ae851"; - uint32_t dataLen = strlen(hexData) / 2; - - uint32_t inLen = dataLen; - uint32_t outLen = dataLen; - - HksBlob message = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; - for (uint32_t ii = 0; ii < dataLen; ii++) { - message.data[ii] = ReadHex((const uint8_t *)&hexData[2 * ii]); - } - - HksBlob cipherText = { .size = outLen, .data = (uint8_t *)HksMalloc(outLen + HKS_PADDING_SUPPLENMENT) }; - - ret = HksCryptoHalDecrypt(&key, &usageSpec, &message, &cipherText); - EXPECT_EQ(HKS_SUCCESS, ret); - HksFree(key.data); - HksFree(message.data); - HksFree(cipherText.data); -} + "de68a475b9453c38ee89a4ccfd895ae851", -/** - * @tc.number : HksCryptoHalRsaOaepDecrypt_025 - * @tc.name : HksCryptoHalRsaOaepDecrypt_025 - * @tc.desc : Using HksCryptoHalDecrypt Decrypt RSA-512-OAEP_SHA256 key failed:keysize +#include + +#include "hks_type.h" +#include "hks_param.h" + +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +#define BIT_NUM_OF_UINT8 8 + +struct GenerateKeyCaseParams { + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct EncryptLocalCaseParams { + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct EncryptServiceCaseParams { + std::string alias; + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + uint32_t keySize; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct DecryptLocalCaseParams { + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct DecryptServiceCaseParams { + std::string alias; + std::vector params; + std::string hexData; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +struct SignLocalCaseParams { + std::vector params; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +struct SignServiceCaseParams { + std::string alias; + std::vector params; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +struct VerifyLocalCaseParams { + std::vector params; + int padding; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +struct VerifyServiceCaseParams { + std::string alias; + std::vector params; + int padding; + HksKeyDigest keyDigest; + uint32_t keySize; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +class HksRsaCommonMt { +protected: + void GenerateKeyTestCase(const GenerateKeyCaseParams &testCaseParams); + + void EncryptLocalTestCase(const EncryptLocalCaseParams &testCaseParams); + + void EncryptServiceTestCase(const EncryptServiceCaseParams &testCaseParams); + + void DecryptLocalTestCase(const DecryptLocalCaseParams &testCaseParams); + + void DecryptServiceTestCase(const DecryptServiceCaseParams &testCaseParams); + + void SignLocalTestCase(const SignLocalCaseParams &testCaseParams); + + void SignServiceTestCase(const SignServiceCaseParams &testCaseParams); + + void VerifyLocalTestCase(const VerifyLocalCaseParams &testCaseParams); + + void VerifyServiceTestCase(const VerifyServiceCaseParams &testCaseParams); +}; +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS +#endif \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_aes_test_mt.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_aes_helper.h similarity index 66% rename from interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_aes_test_mt.h rename to interfaces/innerkits/huks_standard/test/moduletest/include/openssl_aes_helper.h index 86fc3d54..5fadd20d 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_aes_test_mt.h +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_aes_helper.h @@ -14,8 +14,8 @@ * limitations under the License. */ -#ifndef HKS_OPENSSL_RSA_TEST_MT_H -#define HKS_OPENSSL_RSA_TEST_MT_H +#ifndef OPENSSL_AES_HELPER_H +#define OPENSSL_AES_HELPER_H #include @@ -28,24 +28,23 @@ extern "C" { #endif #define AAD_SIZE 16 -#define AES_FAILED ((uint32_t)1) -#define AES_SUCCESS ((uint32_t)0) #define COMPLEMENT_LEN 16 #define IV_SIZE 16 #define OUT_PARAMSET_SIZE 2048 +#define AUTHID_KEY_SIZE 256 int32_t GenerateAesKey(const int key_len, struct HksBlob *randomKey); -uint32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, +int32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, const struct HksBlob *randomKey); -uint32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, +int32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, const struct HksBlob *randomKey); -uint32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, +int32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, const struct HksBlob *randomKey, const struct HksBlob *tagAead); -uint32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, +int32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, const struct HksBlob *randomKey, const struct HksBlob *tagDec); #ifdef __cplusplus diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dh_mt_test.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dh_helper.h similarity index 93% rename from interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dh_mt_test.h rename to interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dh_helper.h index 401f357c..02ffc3f5 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dh_mt_test.h +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dh_helper.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef HKS_OPENSSL_DH_TEST_MT_H -#define HKS_OPENSSL_DH_TEST_MT_H +#ifndef OPENSSL_DH_HELPER_H +#define OPENSSL_DH_HELPER_H #include @@ -32,7 +32,6 @@ extern "C" { #define DH_FAILED 1 #define DH_SUCCESS 0 -#define DH_KEY_SIZE 2048 int32_t DhGenerateKey(const int keyLen, struct HksBlob *key); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dsa_sign_test_mt.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dsa_helper.h similarity index 94% rename from interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dsa_sign_test_mt.h rename to interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dsa_helper.h index d5a244e9..2de29fe3 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_dsa_sign_test_mt.h +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_dsa_helper.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef HKS_OPENSSL_DSA_SIGN_TEST_MT_H -#define HKS_OPENSSL_DSA_SIGN_TEST_MT_H +#ifndef OPENSSL_DSA_SIGN_MT_HELPER_H +#define OPENSSL_DSA_SIGN_MT_HELPER_H #include diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_ecc_mt_test.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_ecc_helper.h similarity index 96% rename from interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_ecc_mt_test.h rename to interfaces/innerkits/huks_standard/test/moduletest/include/openssl_ecc_helper.h index 45a31406..9f5c871a 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_ecc_mt_test.h +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_ecc_helper.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef HKS_OPENSSL_ECC_TEST_MT_H -#define HKS_OPENSSL_ECC_TEST_MT_H +#ifndef OPENSSL_ECC_HELPER_H +#define OPENSSL_ECC_HELPER_H #include diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_hmac_mt_test.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_hmac_helper.h similarity index 94% rename from interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_hmac_mt_test.h rename to interfaces/innerkits/huks_standard/test/moduletest/include/openssl_hmac_helper.h index 794fe749..f5b8df3c 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_hmac_mt_test.h +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_hmac_helper.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef HKS_OPENSSL_HMAC_TEST_MT_H -#define HKS_OPENSSL_HMAC_TEST_MT_H +#ifndef OPENSSL_HMAC_HELPER_H +#define OPENSSL_HMAC_HELPER_H #include diff --git a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_rsa_test_mt.h b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_rsa_helper.h similarity index 95% rename from interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_rsa_test_mt.h rename to interfaces/innerkits/huks_standard/test/moduletest/include/openssl_rsa_helper.h index 2360f5e6..a9a341c3 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/include/hks_openssl_rsa_test_mt.h +++ b/interfaces/innerkits/huks_standard/test/moduletest/include/openssl_rsa_helper.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef HKS_OPENSSL_RSA_TEST_MT_H -#define HKS_OPENSSL_RSA_TEST_MT_H +#ifndef OPENSSL_RSA_MT_HELPER_H +#define OPENSSL_RSA_MT_HELPER_H #include @@ -29,7 +29,7 @@ extern "C" { #endif #define BIT_NUM_OF_UINT8 8 -#define RSA_FAILED 1 +#define RSA_FAILED (-1) #define RSA_SUCCESS 0 void SaveRsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key); diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt.cpp similarity index 34% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt_test.cpp rename to interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt.cpp index fca133c4..9092b21e 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt_test.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_cipher_mt.cpp @@ -13,7 +13,10 @@ * limitations under the License. */ -#include "hks_openssl_aes_test_mt.h" +#include "openssl_aes_helper.h" + +#include +#include #include @@ -21,24 +24,27 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -class HksAesCipherMtTest : public testing::Test {}; - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00100 - * @tc.name : HksAesCipherMtTest00100 - * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00100, TestSize.Level1) -{ - uint8_t key[50] = "AES_128_CBC_PKCS7Padding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { +struct TestCaseParams { + std::vector params; + std::string hexData; + uint32_t inLenAppend = 0; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[IV_SIZE] = {0}; +const uint8_t AAD_DATA[AAD_SIZE] = {0}; +const char TEST_AES_KEY[] = "This is a AES key"; + +const TestCaseParams HUKS_AES_CIPER_MT_00100_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, @@ -48,51 +54,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00100, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00200 - * @tc.name : HksAesCipherMtTest00200 - * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00200, TestSize.Level1) -{ - uint8_t key[50] = "AES_128_CBC_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00200_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, @@ -102,52 +74,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00200, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00300 - * @tc.name : HksAesCipherMtTest00300 - * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00300, TestSize.Level1) -{ - uint8_t key[50] = "AES_128_CTR_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00300_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, @@ -157,52 +94,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00300, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00400 - * @tc.name : HksAesCipherMtTest00400 - * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00400, TestSize.Level1) -{ - uint8_t key[50] = "AES_128_ECB_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00400_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, @@ -212,52 +114,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00400, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00500 - * @tc.name : HksAesCipherMtTest00500 - * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00500, TestSize.Level1) -{ - uint8_t key[50] = "AES_128_ECB_PKCS7Padding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00500_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, @@ -267,61 +134,22 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00500, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00600 - * @tc.name : HksAesCipherMtTest00600 - * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00600, TestSize.Level1) -{ - uint8_t key[50] = "AES_128_GCM_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); +}; - struct HksParam tmpParams[] = { +const TestCaseParams HUKS_AES_CIPER_MT_00600_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, @@ -331,56 +159,18 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00600, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00700 - * @tc.name : HksAesCipherMtTest00700 - * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00700, TestSize.Level1) -{ - uint8_t key[50] = "AES_192_CBC_PKCS7Padding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00700_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, @@ -390,52 +180,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00700, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00800 - * @tc.name : HksAesCipherMtTest00800 - * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00800, TestSize.Level1) -{ - uint8_t key[50] = "AES_192_CBC_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00800_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, @@ -445,52 +200,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00800, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest00900 - * @tc.name : HksAesCipherMtTest00900 - * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00900, TestSize.Level1) -{ - uint8_t key[50] = "AES_192_CTR_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_00900_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, @@ -500,52 +220,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest00900, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01000 - * @tc.name : HksAesCipherMtTest01000 - * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01000, TestSize.Level1) -{ - uint8_t key[50] = "AES_192_ECB_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01000_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, @@ -555,52 +240,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01000, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01100 - * @tc.name : HksAesCipherMtTest01100 - * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01100, TestSize.Level1) -{ - uint8_t key[50] = "AES_192_ECB_PKCS7Padding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01100_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, @@ -610,61 +260,22 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01100, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01200 - * @tc.name : HksAesCipherMtTest01200 - * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01200, TestSize.Level1) -{ - uint8_t key[50] = "AES_192_GCM_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; +}; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { +const TestCaseParams HUKS_AES_CIPER_MT_01200_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, @@ -674,56 +285,18 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01200, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01300 - * @tc.name : HksAesCipherMtTest01300 - * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01300, TestSize.Level1) -{ - uint8_t key[50] = "AES_256_CBC_PKCS7Padding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01300_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, @@ -733,52 +306,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01300, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01400 - * @tc.name : HksAesCipherMtTest01400 - * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01400, TestSize.Level1) -{ - uint8_t key[50] = "AES_256_CBC_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01400_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, @@ -788,52 +326,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01400, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01500 - * @tc.name : HksAesCipherMtTest01500 - * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01500, TestSize.Level1) -{ - uint8_t key[50] = "AES_256_CTR_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01500_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, @@ -843,52 +346,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01500, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01600 - * @tc.name : HksAesCipherMtTest01600 - * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01600, TestSize.Level1) -{ - uint8_t key[50] = "AES_256_ECB_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01600_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, @@ -898,52 +366,17 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01600, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01700 - * @tc.name : HksAesCipherMtTest01700 - * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01700, TestSize.Level1) -{ - uint8_t key[50] = "AES_256_ECB_PKCS7Padding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_CIPER_MT_01700_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, @@ -953,102 +386,277 @@ HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01700, TestSize.Level1) { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); +const TestCaseParams HUKS_AES_CIPER_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksAesCipherMt : public testing::Test { +protected: + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(TEST_AES_KEY), (uint8_t *)TEST_AES_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), testCaseParams.generateKeyResult); + + HksBlob plainText = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + + uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult); + if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) { + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(plainTextDecrypt.data, nullptr); + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), testCaseParams.decryptResult); + EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length()); + EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0); + HksFree(plainTextDecrypt.data); + } + + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); + } +}; - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00100 + * @tc.name : HksAesCipherMt00100 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00100_PARAMS); +} - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00200 + * @tc.name : HksAesCipherMt00200 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00200_PARAMS); +} - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00300 + * @tc.name : HksAesCipherMt00300 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00300_PARAMS); +} - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00400 + * @tc.name : HksAesCipherMt00400 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00400_PARAMS); +} - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00500 + * @tc.name : HksAesCipherMt00500 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00500_PARAMS); +} - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00600 + * @tc.name : HksAesCipherMt00600 + * @tc.desc : Huks generates an aes128 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00600_PARAMS); +} - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00700 + * @tc.name : HksAesCipherMt00700 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00700_PARAMS); } /** - * @tc.number : HksAesCipherMtTest.HksAesCipherMtTest01800 - * @tc.name : HksAesCipherMtTest01800 - * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using - * AES/GCM/nopadding algorithm + * @tc.number : HksAesCipherMt.HksAesCipherMt00800 + * @tc.name : HksAesCipherMt00800 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/nopadding algorithm */ -HWTEST_F(HksAesCipherMtTest, HksAesCipherMtTest01800, TestSize.Level1) +HWTEST_F(HksAesCipherMt, HksAesCipherMt00800, TestSize.Level0) { - uint8_t key[50] = "AES_256_GCM_NOPadding"; - struct HksBlob alias = { .size = strlen((char *)key), .data = key }; + RunTestCase(HUKS_AES_CIPER_MT_00800_PARAMS); +} - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt00900 + * @tc.name : HksAesCipherMt00900 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_00900_PARAMS); +} - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01000 + * @tc.name : HksAesCipherMt01000 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01000_PARAMS); +} - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01100 + * @tc.name : HksAesCipherMt01100 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01100_PARAMS); +} - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01200 + * @tc.name : HksAesCipherMt01200 + * @tc.desc : Huks generates an aes192 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01200_PARAMS); +} - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01300 + * @tc.name : HksAesCipherMt01300 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01300_PARAMS); +} - EXPECT_EQ(HksGenerateKey(&alias, paramInSet, NULL), HKS_SUCCESS); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01400 + * @tc.name : HksAesCipherMt01400 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01400_PARAMS); +} - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01500 + * @tc.name : HksAesCipherMt01500 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01500_PARAMS); +} - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&alias, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(HksDecrypt(&alias, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01600 + * @tc.name : HksAesCipherMt01600 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01600_PARAMS); +} - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01700 + * @tc.name : HksAesCipherMt01700 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01700_PARAMS); +} - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksAesCipherMt.HksAesCipherMt01800 + * @tc.name : HksAesCipherMt01800 + * @tc.desc : Huks generates an aes256 bit key, which can be successfully used by huks to encrypt/decrypt using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesCipherMt, HksAesCipherMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_CIPER_MT_01800_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt.cpp new file mode 100755 index 00000000..1959e40c --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt.cpp @@ -0,0 +1,686 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_aes_helper.h" + +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + uint32_t inLenAppend = 0; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[IV_SIZE] = {0}; +const uint8_t AAD_DATA[AAD_SIZE] = {0}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_DECRYPT_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksAesDecryptMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { .size = AUTHID_KEY_SIZE, .data = (uint8_t *)HksMalloc(AUTHID_KEY_SIZE) }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE); + uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE); + + EXPECT_EQ(GenerateAesKey(keySize, &authId), testCaseParams.generateKeyResult); + + HksBlob plainText = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + + uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(plainTextDecrypt.data, nullptr); + if (blockMode == HKS_MODE_GCM) { + HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) }; + EXPECT_EQ( + AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), testCaseParams.encryptResult); + cipherText.size += AAD_SIZE; + (void)memcpy_s(cipherText.data + AAD_SIZE, AAD_SIZE, tagAead.data, AAD_SIZE); + HksFree(tagAead.data); + } else { + EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), testCaseParams.encryptResult); + } + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), testCaseParams.decryptResult); + if (testCaseParams.decryptResult != HKS_ERROR_NOT_SUPPORTED) { + EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length()); + EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0); + } + + HksFree(authId.data); + HksFree(cipherText.data); + HksFree(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00100 + * @tc.name : HksAesDecryptMt00100 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00100_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00200 + * @tc.name : HksAesDecryptMt00200 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00200_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00300 + * @tc.name : HksAesDecryptMt00300 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00300_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00400 + * @tc.name : HksAesDecryptMt00400 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00400_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00500 + * @tc.name : HksAesDecryptMt00500 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00500_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00600 + * @tc.name : HksAesDecryptMt00600 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using + * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00600_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00700 + * @tc.name : HksAesDecryptMt00700 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00700_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00800 + * @tc.name : HksAesDecryptMt00800 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00800_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt00900 + * @tc.name : HksAesDecryptMt00900 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_00900_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01000 + * @tc.name : HksAesDecryptMt01000 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01000_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01100 + * @tc.name : HksAesDecryptMt01100 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01100_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01200 + * @tc.name : HksAesDecryptMt01200 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using + * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01200_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01300 + * @tc.name : HksAesDecryptMt01300 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01300_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01400 + * @tc.name : HksAesDecryptMt01400 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01400_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01500 + * @tc.name : HksAesDecryptMt01500 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01500_PARAMS); +} +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01600 + * @tc.name : HksAesDecryptMt01600 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01600_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01700 + * @tc.name : HksAesDecryptMt01700 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01700_PARAMS); +} + +/** + * @tc.number : HksAesDecryptMt.HksAesDecryptMt01800 + * @tc.name : HksAesDecryptMt01800 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using + * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesDecryptMt, HksAesDecryptMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_DECRYPT_MT_01800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt_test.cpp deleted file mode 100755 index 33f793b3..00000000 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_decrypt_mt_test.cpp +++ /dev/null @@ -1,1145 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hks_openssl_aes_test_mt.h" - -#include - -#include "hks_api.h" -#include "hks_mem.h" - -using namespace testing::ext; -namespace { -namespace { -const char TEST_AES_128KEY[] = "This is a AES_128 key"; -const char TEST_AES_192KEY[] = "This is a AES_192 key"; -const char TEST_AES_256KEY[] = "This is a AES_256 key"; -static const struct HksParam AES_DECRYPT_00500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; -static const struct HksParam AES_DECRYPT_01100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; -static const struct HksParam AES_DECRYPT_01700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; -} // namespace - -class HksAesDecryptMtTest : public testing::Test {}; - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00100 - * @tc.name : HksAesDecryptMtTest00100 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using - * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00200 - * @tc.name : HksAesDecryptMtTest00200 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using - * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00300 - * @tc.name : HksAesDecryptMtTest00300 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using - * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00400 - * @tc.name : HksAesDecryptMtTest00400 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using - * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00500 - * @tc.name : HksAesDecryptMtTest00500 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using - * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams( - paramInSet, AES_DECRYPT_00500_PARAMS, sizeof(AES_DECRYPT_00500_PARAMS) / sizeof(AES_DECRYPT_00500_PARAMS[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_ERROR_NOT_SUPPORTED); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00600 - * @tc.name : HksAesDecryptMtTest00600 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for OpenSSL encryption using - * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), AES_SUCCESS); - cipherText.size = 32; - (void)memcpy_s(cipherText.data + 16, 16, tagAead.data, 16); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00700 - * @tc.name : HksAesDecryptMtTest00700 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using - * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00800 - * @tc.name : HksAesDecryptMtTest00800 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using - * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest00900 - * @tc.name : HksAesDecryptMtTest00900 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using - * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest00900, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01000 - * @tc.name : HksAesDecryptMtTest01000 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using - * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01100 - * @tc.name : HksAesDecryptMtTest01100 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using - * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams( - paramInSet, AES_DECRYPT_01100_PARAMS, sizeof(AES_DECRYPT_01100_PARAMS) / sizeof(AES_DECRYPT_01100_PARAMS[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_ERROR_NOT_SUPPORTED); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01200 - * @tc.name : HksAesDecryptMtTest01200 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for OpenSSL encryption using - * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), AES_SUCCESS); - cipherText.size = 32; - (void)memcpy_s(cipherText.data + 16, 16, tagAead.data, 16); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01300 - * @tc.name : HksAesDecryptMtTest01300 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using - * AES/CBC/pkcs7padding algorithm and huks decryption using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01400 - * @tc.name : HksAesDecryptMtTest01400 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using - * AES/CBC/nopadding algorithm and huks decryption using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01500 - * @tc.name : HksAesDecryptMtTest01500 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using - * AES/CTR/nopadding algorithm and huks decryption using AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01600 - * @tc.name : HksAesDecryptMtTest01600 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using - * AES/ECB/nopadding algorithm and huks decryption using AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01700 - * @tc.name : HksAesDecryptMtTest01700 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using - * AES/ECB/pkcs7padding algorithm and huks decryption using AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams( - paramInSet, AES_DECRYPT_01700_PARAMS, sizeof(AES_DECRYPT_01700_PARAMS) / sizeof(AES_DECRYPT_01700_PARAMS[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &authId), AES_SUCCESS); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_ERROR_NOT_SUPPORTED); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -} - -/** - * @tc.number : HksAesDecryptMtTest.HksAesDecryptMtTest01800 - * @tc.name : HksAesDecryptMtTest01800 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for OpenSSL encryption using - * AES/GCM/nopadding algorithm and huks decryption using AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesDecryptMtTest, HksAesDecryptMtTest01800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &authId, &tagAead), AES_SUCCESS); - cipherText.size = 32; - (void)memcpy_s(cipherText.data + 16, 16, tagAead.data, 16); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} -} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt.cpp new file mode 100755 index 00000000..ebf88160 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt.cpp @@ -0,0 +1,682 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_aes_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + uint32_t inLenAppend = 0; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[IV_SIZE] = {0}; +const uint8_t AAD_DATA[AAD_SIZE] = {0}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; + +const TestCaseParams HUKS_AES_ENCRYPT_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksAesEncryptMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { .size = AUTHID_KEY_SIZE, .data = (uint8_t *)HksMalloc(AUTHID_KEY_SIZE) }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE); + uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE); + + EXPECT_EQ(GenerateAesKey(keySize, &authId), testCaseParams.generateKeyResult); + + HksBlob plainText = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + + uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(plainTextDecrypt.data, nullptr); + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult); + if (testCaseParams.encryptResult != HKS_ERROR_NOT_SUPPORTED) { + if (blockMode == HKS_MODE_GCM) { + HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) }; + (void)memcpy_s(tagAead.data, AAD_SIZE, cipherText.data + AAD_SIZE, AAD_SIZE); + cipherText.size = AAD_SIZE; + EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId, &tagAead), + testCaseParams.decryptResult); + HksFree(tagAead.data); + } else { + EXPECT_EQ( + AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), testCaseParams.decryptResult); + } + EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length()); + EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0); + } + + HksFree(authId.data); + HksFree(cipherText.data); + HksFree(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00100 + * @tc.name : HksAesEncryptMt00100 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00100_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00200 + * @tc.name : HksAesEncryptMt00200 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00200_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00300 + * @tc.name : HksAesEncryptMt00300 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00300_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00400 + * @tc.name : HksAesEncryptMt00400 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00400_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00500 + * @tc.name : HksAesEncryptMt00500 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00500_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00600 + * @tc.name : HksAesEncryptMt00600 + * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using + * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00600_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00700 + * @tc.name : HksAesEncryptMt00700 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00700_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00800 + * @tc.name : HksAesEncryptMt00800 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00800_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt00900 + * @tc.name : HksAesEncryptMt00900 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_00900_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01000 + * @tc.name : HksAesEncryptMt01000 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01000_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01100 + * @tc.name : HksAesEncryptMt01100 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01100_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01200 + * @tc.name : HksAesEncryptMt01200 + * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using + * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01200_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01300 + * @tc.name : HksAesEncryptMt01300 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01300_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01400 + * @tc.name : HksAesEncryptMt01400 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01400_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01500 + * @tc.name : HksAesEncryptMt01500 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01500_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01600 + * @tc.name : HksAesEncryptMt01600 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01600_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01700 + * @tc.name : HksAesEncryptMt01700 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01700_PARAMS); +} + +/** + * @tc.number : HksAesEncryptMt.HksAesEncryptMt01800 + * @tc.name : HksAesEncryptMt01800 + * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using + * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesEncryptMt, HksAesEncryptMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_ENCRYPT_MT_01800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt_test.cpp deleted file mode 100755 index 02ca3d2a..00000000 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_encrypt_mt_test.cpp +++ /dev/null @@ -1,1127 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hks_openssl_aes_test_mt.h" - -#include - -#include "hks_api.h" -#include "hks_mem.h" - -using namespace testing::ext; -namespace { -namespace { -const char TEST_AES_128KEY[] = "This is a AES_128 key"; -const char TEST_AES_192KEY[] = "This is a AES_192 key"; -const char TEST_AES_256KEY[] = "This is a AES_256 key"; -static const struct HksParam AES_ENCRYPT_00500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; -static const struct HksParam AES_ENCRYPT_01100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; -static const struct HksParam AES_ENCRYPT_01700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; -} // namespace -class HksAesEncryptMtTest : public testing::Test {}; - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00100 - * @tc.name : HksAesEncryptMtTest00100 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using - * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00200 - * @tc.name : HksAesEncryptMtTest00200 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using - * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00300 - * @tc.name : HksAesEncryptMtTest00300 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using - * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00400 - * @tc.name : HksAesEncryptMtTest00400 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using - * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00500 - * @tc.name : HksAesEncryptMtTest00500 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using - * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams( - paramInSet, AES_ENCRYPT_00500_PARAMS, sizeof(AES_ENCRYPT_00500_PARAMS) / sizeof(AES_ENCRYPT_00500_PARAMS[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00600 - * @tc.name : HksAesEncryptMtTest00600 - * @tc.desc : OpenSSL generates an aes128 bit key, which can be successfully used for huks encryption using - * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_128, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - (void)memcpy_s(tagAead.data, 16, cipherText.data + 16, 16); - cipherText.size = 16; - EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId, &tagAead), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00700 - * @tc.name : HksAesEncryptMtTest00700 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using - * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00800 - * @tc.name : HksAesEncryptMtTest00800 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using - * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest00900 - * @tc.name : HksAesEncryptMtTest00900 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using - * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest00900, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01000 - * @tc.name : HksAesEncryptMtTest01000 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using - * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01100 - * @tc.name : HksAesEncryptMtTest01100 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using - * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams( - paramInSet, AES_ENCRYPT_01100_PARAMS, sizeof(AES_ENCRYPT_01100_PARAMS) / sizeof(AES_ENCRYPT_01100_PARAMS[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01200 - * @tc.name : HksAesEncryptMtTest01200 - * @tc.desc : OpenSSL generates an aes192 bit key, which can be successfully used for huks encryption using - * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_192, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - (void)memcpy_s(tagAead.data, 16, cipherText.data + 16, 16); - cipherText.size = 16; - EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId, &tagAead), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01300 - * @tc.name : HksAesEncryptMtTest01300 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using - * AES/CBC/pkcs7padding algorithm, and OpenSSL decrypts using AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01400 - * @tc.name : HksAesEncryptMtTest01400 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using - * AES/CBC/nopadding algorithm, and OpenSSL decrypts using AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01500 - * @tc.name : HksAesEncryptMtTest01500 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using - * AES/CTR/nopadding algorithm, and OpenSSL decrypts using AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01600 - * @tc.name : HksAesEncryptMtTest01600 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using - * AES/ECB/nopadding algorithm, and OpenSSL decrypts using AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01700 - * @tc.name : HksAesEncryptMtTest01700 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using - * AES/ECB/pkcs7padding algorithm, and OpenSSL decrypts using AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams( - paramInSet, AES_ENCRYPT_01700_PARAMS, sizeof(AES_ENCRYPT_01700_PARAMS) / sizeof(AES_ENCRYPT_01700_PARAMS[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -#if defined(_USE_MBEDTLS_) - ASSERT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -#endif -} - -/** - * @tc.number : HksAesEncryptMtTest.HksAesEncryptMtTest01800 - * @tc.name : HksAesEncryptMtTest01800 - * @tc.desc : OpenSSL generates an aes256 bit key, which can be successfully used for huks encryption using - * AES/GCM/nopadding algorithm, and OpenSSL decrypts using AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesEncryptMtTest, HksAesEncryptMtTest01800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; - HksAddParams(paramInSet, &aad, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - GenerateAesKey(HKS_AES_KEY_SIZE_256, &authId); - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - (void)memcpy_s(tagAead.data, 16, cipherText.data + 16, 16); - cipherText.size = 16; - EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &authId, &tagAead), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} -} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt.cpp new file mode 100755 index 00000000..d3708908 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt.cpp @@ -0,0 +1,678 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_aes_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + uint32_t inLenAppend = 0; + + HksErrorCode generateKeyResult; + HksErrorCode encryptResult; + HksErrorCode decryptResult; +}; + +const uint8_t IV[IV_SIZE] = {0}; +const uint8_t AAD_DATA[AAD_SIZE] = {0}; +const char TEST_AES_KEY[] = "This is a AES key"; + +const TestCaseParams HUKS_AES_KEY_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = COMPLEMENT_LEN, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AES_KEY_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, + { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = (uint8_t*)IV } }, + { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(AAD_DATA), .data = (uint8_t*)AAD_DATA } }, + }, + .hexData = "0123456789abcdef", + .inLenAppend = 0, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksAesKeyMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(TEST_AES_KEY), (uint8_t *)TEST_AES_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t blockMode = ReadValueByTag(testCaseParams.params, HKS_TAG_BLOCK_MODE); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(OUT_PARAMSET_SIZE); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); + paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + + HksParam *symmetricParam = NULL; + HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); + HksBlob symmetricKey = { .size = symmetricParam->blob.size, + .data = (uint8_t *)HksMalloc(symmetricParam->blob.size) }; + (void)memcpy_s( + symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); + + HksBlob plainText = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + + uint32_t inLen = testCaseParams.hexData.length() + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(plainTextDecrypt.data, nullptr); + if (blockMode == HKS_MODE_GCM) { + HksBlob tagAead = { .size = AAD_SIZE, .data = (uint8_t *)HksMalloc(AAD_SIZE) }; + EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead), + testCaseParams.encryptResult); + EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead), + testCaseParams.decryptResult); + HksFree(tagAead.data); + } else { + EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), testCaseParams.encryptResult); + EXPECT_EQ( + AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), testCaseParams.decryptResult); + } + EXPECT_EQ(plainTextDecrypt.size, testCaseParams.hexData.length()); + EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, testCaseParams.hexData.length()), 0); + + HksFree(paramSetOut); + HksFree(symmetricKey.data); + HksFree(cipherText.data); + HksFree(plainTextDecrypt.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00100 + * @tc.name : HksAesKeyMt00100 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00100_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00200 + * @tc.name : HksAesKeyMt00200 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00200_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00300 + * @tc.name : HksAesKeyMt00300 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00300_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00400 + * @tc.name : HksAesKeyMt00400 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00400_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00500 + * @tc.name : HksAesKeyMt00500 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00500_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00600 + * @tc.name : HksAesKeyMt00600 + * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00600_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00700 + * @tc.name : HksAesKeyMt00700 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00700_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00800 + * @tc.name : HksAesKeyMt00800 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00800_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt00900 + * @tc.name : HksAesKeyMt00900 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_00900_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01000 + * @tc.name : HksAesKeyMt01000 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01000_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01100 + * @tc.name : HksAesKeyMt01100 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01100_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01200 + * @tc.name : HksAesKeyMt01200 + * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01200_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01300 + * @tc.name : HksAesKeyMt01300 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01300_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01400 + * @tc.name : HksAesKeyMt01400 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CBC/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01400_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01500 + * @tc.name : HksAesKeyMt01500 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/CTR/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01500_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01600 + * @tc.name : HksAesKeyMt01600 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01600_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01700 + * @tc.name : HksAesKeyMt01700 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/ECB/pkcs7padding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01700_PARAMS); +} + +/** + * @tc.number : HksAesKeyMt.HksAesKeyMt01800 + * @tc.name : HksAesKeyMt01800 + * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using + * AES/GCM/nopadding algorithm + */ +HWTEST_F(HksAesKeyMt, HksAesKeyMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_AES_KEY_MT_01800_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt_test.cpp deleted file mode 100755 index dd9bb7f0..00000000 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_aes_key_mt_test.cpp +++ /dev/null @@ -1,1204 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hks_openssl_aes_test_mt.h" - -#include - -#include "hks_api.h" -#include "hks_mem.h" - -using namespace testing::ext; -namespace { -namespace { -const char TEST_AES_128KEY[] = "This is a AES_128 key"; -const char TEST_AES_192KEY[] = "This is a AES_192 key"; -const char TEST_AES_256KEY[] = "This is a AES_256 key"; -} // namespace -class HksAesKeyMtTest : public testing::Test {}; - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00100 - * @tc.name : HksAesKeyMtTest00100 - * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00200 - * @tc.name : HksAesKeyMtTest00200 - * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00300 - * @tc.name : HksAesKeyMtTest00300 - * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00400 - * @tc.name : HksAesKeyMtTest00400 - * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00500 - * @tc.name : HksAesKeyMtTest00500 - * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00600 - * @tc.name : HksAesKeyMtTest00600 - * @tc.desc : Huks generates aes128 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_128KEY), (uint8_t *)TEST_AES_128KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }, - { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }, - }; - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead), AES_SUCCESS); - EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00700 - * @tc.name : HksAesKeyMtTest00700 - * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00800 - * @tc.name : HksAesKeyMtTest00800 - * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest00900 - * @tc.name : HksAesKeyMtTest00900 - * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest00900, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01000 - * @tc.name : HksAesKeyMtTest01000 - * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01100 - * @tc.name : HksAesKeyMtTest01100 - * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01200 - * @tc.name : HksAesKeyMtTest01200 - * @tc.desc : Huks generates aes192 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_192KEY), (uint8_t *)TEST_AES_192KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }, - { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }, - }; - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead), AES_SUCCESS); - EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01300 - * @tc.name : HksAesKeyMtTest01300 - * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CBC/pkcs7padding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01400 - * @tc.name : HksAesKeyMtTest01400 - * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CBC/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01500 - * @tc.name : HksAesKeyMtTest01500 - * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/CTR/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01600 - * @tc.name : HksAesKeyMtTest01600 - * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/ECB/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01700 - * @tc.name : HksAesKeyMtTest01700 - * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/ECB/pkcs7padding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, - }; - - uint8_t iv[IV_SIZE] = {0}; - struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; - HksAddParams(paramInSet, &tagIv, 1); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - EXPECT_EQ(AesEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey), AES_SUCCESS); - EXPECT_EQ(AesDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} - -/** - * @tc.number : HksAesKeyMtTest.HksAesKeyMtTest01800 - * @tc.name : HksAesKeyMtTest01800 - * @tc.desc : Huks generates aes256 bit key, which can be successfully used for OpenSSL encryption/decryption using - * AES/GCM/nopadding algorithm - */ -HWTEST_F(HksAesKeyMtTest, HksAesKeyMtTest01800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_AES_256KEY), (uint8_t *)TEST_AES_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - uint8_t iv[IV_SIZE] = {0}; - uint8_t aadData[AAD_SIZE] = {0}; - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }, - { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }, - { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }, - }; - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(OUT_PARAMSET_SIZE); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, OUT_PARAMSET_SIZE, 0, OUT_PARAMSET_SIZE); - paramSetOut->paramSetSize = OUT_PARAMSET_SIZE; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *symmetricParam = NULL; - HksGetParam(paramSetOut, HKS_TAG_SYMMETRIC_KEY_DATA, &symmetricParam); - HksBlob symmetricKey = { .size = symmetricParam->blob.size, .data = (uint8_t *)malloc(symmetricParam->blob.size) }; - (void)memcpy_s(symmetricKey.data, symmetricParam->blob.size, symmetricParam->blob.data, symmetricParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; - - uint32_t inLen = dataLen + COMPLEMENT_LEN; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(plainTextDecrypt.data, nullptr); - HksBlob tagAead = { .size = 16, .data = (uint8_t *)HksMalloc(16) }; - EXPECT_EQ(AesGCMEncrypt(paramInSet, &plainText, &cipherText, &symmetricKey, &tagAead), AES_SUCCESS); - EXPECT_EQ(AesGCMDecrypt(paramInSet, &cipherText, &plainTextDecrypt, &symmetricKey, &tagAead), AES_SUCCESS); - - EXPECT_EQ(plainTextDecrypt.size, dataLen); - EXPECT_EQ(HksMemCmp(plainText.data, plainTextDecrypt.data, dataLen), 0); - - free(paramSetOut); - free(symmetricKey.data); - free(cipherText.data); - free(plainTextDecrypt.data); - HksFreeParamSet(¶mInSet); -} -} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt.cpp new file mode 100755 index 00000000..112113db --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt.cpp @@ -0,0 +1,908 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_ecc_helper.h" +#include "openssl_dh_helper.h" + +#include + +#include "hks_api.h" +#include "hks_config.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector generateKeyParams; + std::vector agreeKeyParams; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode agreeResult; +}; + +const char ALISE_KEY[] = "This is a alise key"; +const char BOB_KEY[] = "This is a bob key"; +const uint32_t KEY_MEMORY = 4096; + +int32_t LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, const struct HksParamSet *paramSetIn, + struct HksBlob *priKey, struct HksBlob *pubKey) +{ + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + if (keyLen == 0) { + return HKS_FAILURE; + } + + uint8_t *localData = (uint8_t *)HksMalloc(keyLen); + if (localData == NULL) { + return HKS_FAILURE; + } + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = { .size = keyLen, .data = localData } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + if (HksGenerateKey(authId, paramSetIn, paramOutSet) != HKS_SUCCESS) { + return HKS_FAILURE; + } + + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + priKey->size = priParam->blob.size; + (void)memcpy_s(priKey->data, priKey->size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + pubKey->size = pubParam->blob.size; + (void)memcpy_s(pubKey->data, pubKey->size, pubParam->blob.data, pubParam->blob.size); + + HksFree(localData); + HksFreeParamSet(¶mOutSet); + return HKS_SUCCESS; +} + +const TestCaseParams HUKS_AGREE_MT_00100_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00200_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00300_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00400_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00500_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00600_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00700_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00800_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_00900_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01000_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01100_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01200_PARAMS = { + .generateKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +#ifdef HKS_SUPPORT_DH_C +const TestCaseParams HUKS_AGREE_MT_01300_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01400_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01500_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01600_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01700_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01800_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_01900_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_02000_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_AGREE_MT_02100_PARAMS = { + .agreeKeyParams = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .agreeResult = HKS_SUCCESS, +}; +#endif +} // namespace + +class HksAgreeMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void ServiceAgreeScenario(const TestCaseParams &testCaseParams, const struct HksParamSet *generateKeyParams, + struct HksBlob *agreeKeyAlise, struct HksBlob *agreeKeyBob) + { + struct HksParamSet *agreeKeyParams = NULL; + HksInitParamSet(&agreeKeyParams); + HksAddParams(agreeKeyParams, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size()); + HksBuildParamSet(&agreeKeyParams); +#ifdef HKS_SUPPORT_DH_C + uint32_t algorithm = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_ALGORITHM); +#endif + uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE); + struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + + HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + + EXPECT_EQ(HksGenerateKey(&bob, generateKeyParams, NULL), testCaseParams.generateKeyResult); + + HksBlob x509KeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob x509KeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(HksExportPublicKey(&bob, generateKeyParams, &x509KeyBob), HKS_SUCCESS); +#ifdef HKS_SUPPORT_DH_C + if (algorithm == HKS_ALG_ECDH) { +#endif + EXPECT_EQ(ECCGenerateKey(keySize, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); + EXPECT_EQ(EcdhAgreeKey(keySize, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult); + + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); +#ifdef HKS_SUPPORT_DH_C + } else if (algorithm == HKS_ALG_DH) { + EXPECT_EQ(DhGenerateKey(keySize, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS); + EXPECT_EQ(DhAgreeKey(keySize, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult); + + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS); + } +#endif + + EXPECT_EQ(HksAgreeKey(agreeKeyParams, &bob, &x509KeyAlise, agreeKeyBob), testCaseParams.agreeResult); + + HksFree(alise.data); + HksFree(x509KeyAlise.data); + HksFree(x509KeyBob.data); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + HksFreeParamSet(&agreeKeyParams); + } + + void LocalAgreeScenario(const TestCaseParams &testCaseParams, const struct HksParamSet *generateKeyParams, + struct HksBlob *agreeKeyAlise, struct HksBlob *agreeKeyBob, int32_t scenario) + { + struct HksParamSet *agreeKeyParams = NULL; + HksInitParamSet(&agreeKeyParams); + HksAddParams(agreeKeyParams, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size()); + HksBuildParamSet(&agreeKeyParams); + uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE); + HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + if (scenario == 0) { + struct HksBlob alise = { (uint32_t)strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + HksBlob priKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob priKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(LocalHksGenerate(keySize, &alise, generateKeyParams, &priKeyAlise, &pubKeyAlise), + testCaseParams.generateKeyResult); + EXPECT_EQ(LocalHksGenerate(keySize, &bob, generateKeyParams, &priKeyBob, &pubKeyBob), + testCaseParams.generateKeyResult); + EXPECT_EQ(EcdhAgreeKey(keySize, &priKeyAlise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult); + EXPECT_EQ(EcdhAgreeKey(keySize, &priKeyBob, &pubKeyAlise, agreeKeyBob), testCaseParams.agreeResult); + HksFree(priKeyAlise.data); + HksFree(priKeyBob.data); + } else if (scenario == 1) { + struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + struct HksBlob bob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(ECCGenerateKey(keySize, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(ECCGenerateKey(keySize, &bob), testCaseParams.generateKeyResult); + EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); + EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); + EXPECT_EQ(HksAgreeKey(agreeKeyParams, &alise, &pubKeyBob, agreeKeyAlise), testCaseParams.agreeResult); + EXPECT_EQ(HksAgreeKey(agreeKeyParams, &bob, &pubKeyAlise, agreeKeyBob), testCaseParams.agreeResult); + HksFree(alise.data); + HksFree(bob.data); + } + HksFreeParamSet(&agreeKeyParams); + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + } + + void EcdhRunTestCase(const TestCaseParams &testCaseParams, int32_t scenario) + { + struct HksParamSet *generateKeyParams = NULL; + HksInitParamSet(&generateKeyParams); + HksAddParams( + generateKeyParams, testCaseParams.generateKeyParams.data(), testCaseParams.generateKeyParams.size()); + HksBuildParamSet(&generateKeyParams); + + uint32_t storage = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_STORAGE_FLAG); + + HksBlob agreeKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob agreeKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + + if (storage == HKS_STORAGE_TEMP) { + LocalAgreeScenario(testCaseParams, generateKeyParams, &agreeKeyAlise, &agreeKeyBob, scenario); + } else if (storage == HKS_STORAGE_PERSISTENT) { + ServiceAgreeScenario(testCaseParams, generateKeyParams, &agreeKeyAlise, &agreeKeyBob); + } + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(&generateKeyParams); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); + } + +#ifdef HKS_SUPPORT_DH_C + void DhRunTestCase(const TestCaseParams &testCaseParams, int32_t scenario) + { + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + HksAddParams(paramInSet, testCaseParams.agreeKeyParams.data(), testCaseParams.agreeKeyParams.size()); + HksBuildParamSet(¶mInSet); + + uint32_t keySize = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_SIZE); + uint32_t storage = ReadValueByTag(testCaseParams.agreeKeyParams, HKS_TAG_KEY_STORAGE_FLAG); + + HksBlob agreeKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob agreeKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + + if (storage == HKS_STORAGE_TEMP) { + HksBlob pubKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob pubKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + if (scenario == 0) { + struct HksBlob alise = { (uint32_t)strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; + struct HksBlob bob = { (uint32_t)strlen(BOB_KEY), (uint8_t *)BOB_KEY }; + HksBlob priKeyAlise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + HksBlob priKeyBob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(LocalHksGenerate(keySize, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), + testCaseParams.generateKeyResult); + EXPECT_EQ(LocalHksGenerate(keySize, &bob, paramInSet, &priKeyBob, &pubKeyBob), + testCaseParams.generateKeyResult); + EXPECT_EQ(DhAgreeKey(keySize, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), testCaseParams.agreeResult); + EXPECT_EQ(DhAgreeKey(keySize, &priKeyBob, &pubKeyAlise, &agreeKeyBob), testCaseParams.agreeResult); + HksFree(priKeyAlise.data); + HksFree(priKeyBob.data); + } else if (scenario == 1) { + struct HksBlob alise = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + struct HksBlob bob = { .size = KEY_MEMORY, .data = (uint8_t *)HksMalloc(KEY_MEMORY) }; + EXPECT_EQ(DhGenerateKey(keySize, &alise), testCaseParams.generateKeyResult); + EXPECT_EQ(DhGenerateKey(keySize, &bob), testCaseParams.generateKeyResult); + EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); + EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS); + EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), testCaseParams.agreeResult); + EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), testCaseParams.agreeResult); + HksFree(alise.data); + HksFree(bob.data); + } + HksFree(pubKeyAlise.data); + HksFree(pubKeyBob.data); + } else if (storage == HKS_STORAGE_PERSISTENT) { + ServiceAgreeScenario(testCaseParams, paramInSet, &agreeKeyAlise, &agreeKeyBob); + } + EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); + EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); + + HksFreeParamSet(¶mInSet); + HksFree(agreeKeyAlise.data); + HksFree(agreeKeyBob.data); + } +#endif +}; + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00100 + * @tc.name : HksAgreeMt00100 + * @tc.desc : Both parties use huks to generate an ecc224 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00100, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00100_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00200 + * @tc.name : HksAgreeMt00200 + * @tc.desc : Both parties use huks to generate an ecc256 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00200, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00200_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00300 + * @tc.name : HksAgreeMt00300 + * @tc.desc : Both parties use huks to generate an ecc384 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00300, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00300_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00400 + * @tc.name : HksAgreeMt00400 + * @tc.desc : Both parties use huks to generate an ecc521 bit key, which can be successfully used in OpenSSL to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00400, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00400_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00500 + * @tc.name : HksAgreeMt00500 + * @tc.desc : Both parties use OpenSSL to generate an ecc224 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00500, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00500_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00600 + * @tc.name : HksAgreeMt00600 + * @tc.desc : Both parties use OpenSSL to generate an ecc256 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00600, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00600_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00700 + * @tc.name : HksAgreeMt00700 + * @tc.desc : Both parties use OpenSSL to generate an ecc384 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00700, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00700_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00800 + * @tc.name : HksAgreeMt00800 + * @tc.desc : Both parties use OpenSSL to generate an ecc521 bit key, which can be successfully used in huks to + * negotiate using the ECDH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00800, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00800_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt00900 + * @tc.name : HksAgreeMt00900 + * @tc.desc : One party uses the key of ECC224 for openssl negotiation, and the other party uses the key of ECC224 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt00900, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_00900_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01000 + * @tc.name : HksAgreeMt01000 + * @tc.desc : One party uses the key of ECC256 for openssl negotiation, and the other party uses the key of ECC256 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01000, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_01000_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01100 + * @tc.name : HksAgreeMt01100 + * @tc.desc : One party uses the key of ECC384 for openssl negotiation, and the other party uses the key of ECC384 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01100, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_01100_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01200 + * @tc.name : HksAgreeMt01200 + * @tc.desc : One party uses the key of ECC521 for openssl negotiation, and the other party uses the key of ECC521 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01200, TestSize.Level0) +{ + EcdhRunTestCase(HUKS_AGREE_MT_01200_PARAMS, 0); +} + +#ifdef HKS_SUPPORT_DH_C +/** + * @tc.number : HksAgreeMt.HksAgreeMt01300 + * @tc.name : HksAgreeMt01300 + * @tc.desc : Both parties use huks to generate an dh2048 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01300, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01300_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01400 + * @tc.name : HksAgreeMt01400 + * @tc.desc : Both parties use huks to generate an dh3072 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01400, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01400_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01500 + * @tc.name : HksAgreeMt01500 + * @tc.desc : Both parties use huks to generate an dh4096 bit key, which can be successfully used in OpenSSL to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01500, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01500_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01600 + * @tc.name : HksAgreeMt01600 + * @tc.desc : Both parties use OpenSSL to generate an dh2048 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01600, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01600_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01700 + * @tc.name : HksAgreeMt01700 + * @tc.desc : Both parties use OpenSSL to generate an dh3072 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01700, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01700_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01800 + * @tc.name : HksAgreeMt01800 + * @tc.desc : Both parties use OpenSSL to generate an dh4096 bit key, which can be successfully used in huks to + * negotiate using the DH algorithm + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01800, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01800_PARAMS, 1); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt01900 + * @tc.name : HksAgreeMt01900 + * @tc.desc : One party uses the key of dh2048 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt01900, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_01900_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt02000 + * @tc.name : HksAgreeMt02000 + * @tc.desc : One party uses the key of dh3072 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt02000, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_02000_PARAMS, 0); +} + +/** + * @tc.number : HksAgreeMt.HksAgreeMt02100 + * @tc.name : HksAgreeMt02100 + * @tc.desc : One party uses the key of dh4096 for openssl negotiation, and the other party uses the key of dh2048 + * for huks negotiation + */ +HWTEST_F(HksAgreeMt, HksAgreeMt02100, TestSize.Level0) +{ + DhRunTestCase(HUKS_AGREE_MT_02100_PARAMS, 0); +} +#endif +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt_test.cpp deleted file mode 100755 index 48320683..00000000 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_agree_mt_test.cpp +++ /dev/null @@ -1,1176 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hks_openssl_ecc_mt_test.h" -#include "hks_openssl_dh_mt_test.h" - -#include - -#include "hks_api.h" -#include "hks_mem.h" -#include "hks_param.h" - -using namespace testing::ext; -namespace { -namespace { -const char ALISE_KEY[] = "This is a alise key"; -const char BOB_KEY[] = "This is a bob key"; - -int32_t LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, const struct HksParamSet *paramSetIn, - struct HksBlob *priKey, struct HksBlob *pubKey) -{ - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - if (keyLen == 0) { - return HKS_FAILURE; - } - - uint8_t *localData = (uint8_t *)HksMalloc(keyLen); - if (localData == NULL) { - return HKS_FAILURE; - } - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = { .size = keyLen, .data = localData } }; - HksAddParams(paramOutSet, &localKey, 1); - HksBuildParamSet(¶mOutSet); - - if (HksGenerateKey(authId, paramSetIn, paramOutSet) != HKS_SUCCESS) { - return HKS_FAILURE; - } - - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - priKey->size = priParam->blob.size; - (void)memcpy_s(priKey->data, priKey->size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - pubKey->size = pubParam->blob.size; - (void)memcpy_s(pubKey->data, pubKey->size, pubParam->blob.data, pubParam->blob.size); - - HksFree(localData); - HksFreeParamSet(¶mOutSet); - return HKS_SUCCESS; -} -} // namespace -class HksAgreeMtTest : public testing::Test {}; - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00100 - * @tc.name : HksAgreeMtTest00100 - * @tc.desc : Both parties use huks to generate an ecc224 bit key, which can be successfully used in OpenSSL to - * negotiate using the ECDH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00100, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - HksBlob priKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob priKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_224, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_224, &priKeyBob, &pubKeyAlise, &agreeKeyBob), ECC_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(priKeyAlise.data); - free(priKeyBob.data); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00200 - * @tc.name : HksAgreeMtTest00200 - * @tc.desc : Both parties use huks to generate an ecc256 bit key, which can be successfully used in OpenSSL to - * negotiate using the ECDH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00200, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - HksBlob priKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob priKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_256, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_256, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_256, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_256, &priKeyBob, &pubKeyAlise, &agreeKeyBob), ECC_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(priKeyAlise.data); - free(priKeyBob.data); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00300 - * @tc.name : HksAgreeMtTest00300 - * @tc.desc : Both parties use huks to generate an ecc384 bit key, which can be successfully used in OpenSSL to - * negotiate using the ECDH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00300, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - HksBlob priKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob priKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_384, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_384, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_384, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_384, &priKeyBob, &pubKeyAlise, &agreeKeyBob), ECC_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(priKeyAlise.data); - free(priKeyBob.data); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00400 - * @tc.name : HksAgreeMtTest00400 - * @tc.desc : Both parties use huks to generate an ecc521 bit key, which can be successfully used in OpenSSL to - * negotiate using the ECDH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00400, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - HksBlob priKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob priKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_521, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(LocalHksGenerate(HKS_ECC_KEY_SIZE_521, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_521, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_521, &priKeyBob, &pubKeyAlise, &agreeKeyBob), ECC_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(priKeyAlise.data); - free(priKeyBob.data); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00500 - * @tc.name : HksAgreeMtTest00500 - * @tc.desc : Both parties use OpenSSL to generate an ecc224 bit key, which can be successfully used in huks to - * negotiate using the ECDH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00500, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &alise), ECC_SUCCESS); - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &bob), ECC_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); - EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00600 - * @tc.name : HksAgreeMtTest00600 - * @tc.desc : Both parties use OpenSSL to generate an ecc256 bit key, which can be successfully used in huks to - * negotiate using the ECDH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00600, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &alise), ECC_SUCCESS); - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &bob), ECC_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); - EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00700 - * @tc.name : HksAgreeMtTest00700 - * @tc.desc : Both parties use OpenSSL to generate an ecc384 bit key, which can be successfully used in huks to - * negotiate using the ECDH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00700, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &alise), ECC_SUCCESS); - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &bob), ECC_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); - EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00800 - * @tc.name : HksAgreeMtTest00800 - * @tc.desc : Both parties use OpenSSL to generate an ecc521 bit key, which can be successfully used in huks to - * negotiate using the ECDH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00800, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &alise), ECC_SUCCESS); - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &bob), ECC_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); - EXPECT_EQ(GetEccPubKey(&bob, &pubKeyBob), ECC_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest00900 - * @tc.name : HksAgreeMtTest00900 - * @tc.desc : One party uses the key of ECC224 for openssl negotiation, and the other party uses the key of ECC224 - * for huks negotiation - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest00900, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &alise), ECC_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); - HksBlob x509KeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); - HksBlob x509KeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); - struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_224, &alise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(x509KeyAlise.data); - free(x509KeyBob.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01000 - * @tc.name : HksAgreeMtTest01000 - * @tc.desc : One party uses the key of ECC256 for openssl negotiation, and the other party uses the key of ECC256 - * for huks negotiation - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01000, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &alise), ECC_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); - HksBlob x509KeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); - HksBlob x509KeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); - struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_256, &alise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(x509KeyAlise.data); - free(x509KeyBob.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01100 - * @tc.name : HksAgreeMtTest01100 - * @tc.desc : One party uses the key of ECC384 for openssl negotiation, and the other party uses the key of ECC384 - * for huks negotiation - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01100, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &alise), ECC_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); - HksBlob x509KeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); - HksBlob x509KeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); - struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_384, &alise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(x509KeyAlise.data); - free(x509KeyBob.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01200 - * @tc.name : HksAgreeMtTest01200 - * @tc.desc : One party uses the key of ECC521 for openssl negotiation, and the other party uses the key of ECC521 - * for huks negotiation - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01200, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &alise), ECC_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&alise, &pubKeyAlise), ECC_SUCCESS); - HksBlob x509KeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKeyAlise, &x509KeyAlise), ECC_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); - HksBlob x509KeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); - struct HksBlob pubKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509KeyBob, &pubKeyBob), ECC_SUCCESS); - - HksBlob agreeKeyAlise = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - - EXPECT_EQ(EcdhAgreeKey(HKS_ECC_KEY_SIZE_521, &alise, &pubKeyBob, &agreeKeyAlise), ECC_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(x509KeyAlise.data); - free(x509KeyBob.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -#ifdef HKS_SUPPORT_DH_C -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01300 - * @tc.name : HksAgreeMtTest01300 - * @tc.desc : Both parties use huks to generate an dh2048 bit key, which can be successfully used in OpenSSL to - * negotiate using the DH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01300, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - HksBlob priKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob priKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_2048, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_2048, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_2048, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_2048, &priKeyBob, &pubKeyAlise, &agreeKeyBob), DH_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(priKeyAlise.data); - free(priKeyBob.data); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01400 - * @tc.name : HksAgreeMtTest01400 - * @tc.desc : Both parties use huks to generate an dh3072 bit key, which can be successfully used in OpenSSL to - * negotiate using the DH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01400, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - HksBlob priKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob priKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_3072, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_3072, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_3072, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_3072, &priKeyBob, &pubKeyAlise, &agreeKeyBob), DH_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(priKeyAlise.data); - free(priKeyBob.data); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01500 - * @tc.name : HksAgreeMtTest01500 - * @tc.desc : Both parties use huks to generate an dh4096 bit key, which can be successfully used in OpenSSL to - * negotiate using the DH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01500, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - HksBlob priKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob priKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_4096, &alise, paramInSet, &priKeyAlise, &pubKeyAlise), HKS_SUCCESS); - EXPECT_EQ(LocalHksGenerate(HKS_DH_KEY_SIZE_4096, &bob, paramInSet, &priKeyBob, &pubKeyBob), HKS_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_4096, &priKeyAlise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_4096, &priKeyBob, &pubKeyAlise, &agreeKeyBob), DH_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(priKeyAlise.data); - free(priKeyBob.data); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01600 - * @tc.name : HksAgreeMtTest01600 - * @tc.desc : Both parties use OpenSSL to generate an dh2048 bit key, which can be successfully used in huks to - * negotiate using the DH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01600, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_2048, &alise), DH_SUCCESS); - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_2048, &bob), DH_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); - EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01700 - * @tc.name : HksAgreeMtTest01700 - * @tc.desc : Both parties use OpenSSL to generate an dh3072 bit key, which can be successfully used in huks to - * negotiate using the DH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01700, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_3072, &alise), DH_SUCCESS); - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_3072, &bob), DH_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); - EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01800 - * @tc.name : HksAgreeMtTest01800 - * @tc.desc : Both parties use OpenSSL to generate an dh4096 bit key, which can be successfully used in huks to - * negotiate using the DH algorithm - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01800, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_4096, &alise), DH_SUCCESS); - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_4096, &bob), DH_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); - EXPECT_EQ(DhGetDhPubKey(&bob, &pubKeyBob), DH_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(HksAgreeKey(paramInSet, &alise, &pubKeyBob, &agreeKeyAlise), HKS_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &pubKeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest01900 - * @tc.name : HksAgreeMtTest01900 - * @tc.desc : One party uses the key of dh2048 for openssl negotiation, and the other party uses the key of dh2048 - * for huks negotiation - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest01900, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_2048, &alise), DH_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); - HksBlob x509KeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); - HksBlob x509KeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); - struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_2048, &alise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(x509KeyAlise.data); - free(x509KeyBob.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest02000 - * @tc.name : HksAgreeMtTest02000 - * @tc.desc : One party uses the key of dh3072 for openssl negotiation, and the other party uses the key of dh2048 - * for huks negotiation - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest02000, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_3072, &alise), DH_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); - HksBlob x509KeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); - HksBlob x509KeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); - struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_3072, &alise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(x509KeyAlise.data); - free(x509KeyBob.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} - -/** - * @tc.number : HksAgreeMtTest.HksAgreeMtTest02100 - * @tc.name : HksAgreeMtTest02100 - * @tc.desc : One party uses the key of dh4096 for openssl negotiation, and the other party uses the key of dh2048 - * for huks negotiation - */ -HWTEST_F(HksAgreeMtTest, HksAgreeMtTest02100, TestSize.Level1) -{ - struct HksBlob alise = { strlen(ALISE_KEY), (uint8_t *)ALISE_KEY }; - struct HksBlob bob = { strlen(BOB_KEY), (uint8_t *)BOB_KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(DhGenerateKey(HKS_DH_KEY_SIZE_4096, &alise), DH_SUCCESS); - - struct HksBlob pubKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhGetDhPubKey(&alise, &pubKeyAlise), DH_SUCCESS); - HksBlob x509KeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhHksBlobToX509(&pubKeyAlise, &x509KeyAlise), DH_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&bob, paramInSet, NULL), HKS_SUCCESS); - HksBlob x509KeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&bob, paramInSet, &x509KeyBob), HKS_SUCCESS); - struct HksBlob pubKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - EXPECT_EQ(DhX509ToHksBlob(&x509KeyBob, &pubKeyBob), DH_SUCCESS); - - HksBlob agreeKeyAlise = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - HksBlob agreeKeyBob = { .size = DH_KEY_SIZE, .data = (uint8_t *)malloc(DH_KEY_SIZE) }; - - EXPECT_EQ(DhAgreeKey(HKS_DH_KEY_SIZE_4096, &alise, &pubKeyBob, &agreeKeyAlise), DH_SUCCESS); - EXPECT_EQ(HksAgreeKey(paramInSet, &bob, &x509KeyAlise, &agreeKeyBob), HKS_SUCCESS); - - EXPECT_EQ(agreeKeyAlise.size, agreeKeyBob.size); - EXPECT_EQ(HksMemCmp(agreeKeyAlise.data, agreeKeyBob.data, agreeKeyAlise.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKeyAlise.data); - free(x509KeyAlise.data); - free(x509KeyBob.data); - free(pubKeyBob.data); - free(agreeKeyAlise.data); - free(agreeKeyBob.data); -} -#endif -} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_mt.cpp new file mode 100755 index 00000000..4ec0c148 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_mt.cpp @@ -0,0 +1,1137 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_dsa_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const char TEST_KEY_AUTH_ID[] = "This is a test auth id for DSA"; +const int SET_SIZE_4096 = 4096; +const int KEY_SIZE_1024 = 1024; + +struct TestCaseParams { + std::vector params; + HksKeyDigest keyDigest; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const TestCaseParams HKS_DSA_MT_00100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00800_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_00900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01000_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA256, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA256, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA256, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01400_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB } }, + .keyDigest = HKS_DIGEST_SHA256, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01800_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_01900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02000_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, +#if defined(_USE_MBEDTLS_) + .generateKeyResult = HKS_ERROR_NOT_SUPPORTED, +#else + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; + +const TestCaseParams HKS_DSA_MT_02500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .verifyResult = HKS_ERROR_INVALID_ARGUMENT, +#else + .verifyResult = HKS_SUCCESS, +#endif +}; +} // namespace + +class HksDsaMt : public testing::Test { +protected: + void GenerateKeyTestCase(const TestCaseParams &testCaseParams) + { + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = NULL; + HksInitParamSet(¶mSetOut); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) } }; + HksAddParams(paramSetOut, &localKey, 1); + + HksBuildParamSet(¶mSetOut); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, testCaseParams.keyDigest), + testCaseParams.signResult); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, testCaseParams.keyDigest), + testCaseParams.verifyResult); + + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(signData.data); + } + HksFree(localKey.blob.data); + HksFreeParamSet(¶mSetOut); + HksFreeParamSet(¶mInSet); + } + + void SignLocalTestCase(const TestCaseParams &testCaseParams) + { + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = NULL; + HksInitParamSet(¶mSetOut); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) } }; + HksAddParams(paramSetOut, &localKey, 1); + + HksBuildParamSet(¶mSetOut); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), testCaseParams.signResult); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, testCaseParams.keyDigest), + testCaseParams.verifyResult); + + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(signData.data); + } + HksFree(localKey.blob.data); + HksFreeParamSet(¶mSetOut); + HksFreeParamSet(¶mInSet); + } + + void SignServiceTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = NULL; + HksInitParamSet(¶mSetOut); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) } }; + HksAddParams(paramSetOut, &localKey, 1); + + HksBuildParamSet(¶mSetOut); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslDsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); + + uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t dsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; + EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)HksMalloc(dsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), testCaseParams.signResult); + + EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, testCaseParams.keyDigest), + testCaseParams.verifyResult); + + HksFree(publicKey.data); + HksFree(signData.data); + } + HksFree(localKey.blob.data); + HksFreeParamSet(¶mSetOut); + HksFreeParamSet(¶mInSet); + } + + void VerifyLocalTestCase(const TestCaseParams &testCaseParams) + { + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = NULL; + HksInitParamSet(¶mSetOut); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) } }; + HksAddParams(paramSetOut, &localKey, 1); + + HksBuildParamSet(¶mSetOut); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + if (testCaseParams.generateKeyResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, + .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, testCaseParams.keyDigest), + testCaseParams.signResult); + + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), testCaseParams.verifyResult); + + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(signData.data); + } + HksFree(localKey.blob.data); + HksFreeParamSet(¶mSetOut); + HksFreeParamSet(¶mInSet); + } + + void VerifyServiceTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(opensslDsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + + EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); + ASSERT_NE(pkey, nullptr); + + DsaGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); + + EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, testCaseParams.keyDigest), + testCaseParams.signResult); + + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), testCaseParams.verifyResult); + + EVP_PKEY_free(pkey); + HksFree(signData.data); + HksFree(x509Key.data); + HksFree(opensslDsaKeyInfo.data); + HksFreeParamSet(¶mInSet); + } +}; + +/** + * @tc.number : HksDsaMT00100 + * @tc.name : HksDsaMT00100 + * @tc.desc : Test huks generate key (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00100, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_00100_PARAMS); +} + +/** + * @tc.number : HksDsaMT00200 + * @tc.name : HksDsaMT00200 + * @tc.desc : Test huks sign (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00200, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_00200_PARAMS); +} + +/** + * @tc.number : HksDsaMT00300 + * @tc.name : HksDsaMT00300 + * @tc.desc : Test huks sign (1024/SHA1withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT00300, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_00300_PARAMS); +} + +/** + * @tc.number : HksDsaMT00400 + * @tc.name : HksDsaMT00400 + * @tc.desc : Test huks Verify (1024/SHA1withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00400, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_00400_PARAMS); +} + +/** + * @tc.number : HksDsaMT00500 + * @tc.name : HksDsaMT00500 + * @tc.desc : Test huks Verify (1024/SHA1withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT00500, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_00500_PARAMS); +} + +/** + * @tc.number : HksDsaMT00600 + * @tc.name : HksDsaMT00600 + * @tc.desc : Test huks generate key (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00600, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_00600_PARAMS); +} + +/** + * @tc.number : HksDsaMT00700 + * @tc.name : HksDsaMT00700 + * @tc.desc : Test huks sign (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00700, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_00700_PARAMS); +} + +/** + * @tc.number : HksDsaMT00800 + * @tc.name : HksDsaMT00800 + * @tc.desc : Test huks sign (1024/SHA224withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT00800, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_00800_PARAMS); +} + +/** + * @tc.number : HksDsaMT00900 + * @tc.name : HksDsaMT00900 + * @tc.desc : Test huks Verify (1024/SHA224withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT00900, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_00900_PARAMS); +} + +/** + * @tc.number : HksDsaMT01000 + * @tc.name : HksDsaMT01000 + * @tc.desc : Test huks Verify (1024/SHA224withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT01000, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_01000_PARAMS); +} + +/** + * @tc.number : HksDsaMT01100 + * @tc.name : HksDsaMT01100 + * @tc.desc : Test huks generate key (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01100, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_01100_PARAMS); +} + +/** + * @tc.number : HksDsaMT01200 + * @tc.name : HksDsaMT01200 + * @tc.desc : Test huks sign (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01200, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_01200_PARAMS); +} + +/** + * @tc.number : HksDsaMT01300 + * @tc.name : HksDsaMT01300 + * @tc.desc : Test huks sign (1024/SHA256withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT01300, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_01300_PARAMS); +} + +/** + * @tc.number : HksDsaMT01400 + * @tc.name : HksDsaMT01400 + * @tc.desc : Test huks Verify (1024/SHA256withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01400, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_01400_PARAMS); +} + +/** + * @tc.number : HksDsaMT01500 + * @tc.name : HksDsaMT01500 + * @tc.desc : Test huks Verify (1024/SHA256withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT01500, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_01500_PARAMS); +} + +/** + * @tc.number : HksDsaMT01600 + * @tc.name : HksDsaMT01600 + * @tc.desc : Test huks generate key (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01600, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_01600_PARAMS); +} + +/** + * @tc.number : HksDsaMT01700 + * @tc.name : HksDsaMT01700 + * @tc.desc : Test huks sign (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01700, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_01700_PARAMS); +} + +/** + * @tc.number : HksDsaMT01800 + * @tc.name : HksDsaMT01800 + * @tc.desc : Test huks sign (1024/SHA384withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT01800, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_01800_PARAMS); +} + +/** + * @tc.number : HksDsaMT01900 + * @tc.name : HksDsaMT01900 + * @tc.desc : Test huks Verify (1024/SHA384withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT01900, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_01900_PARAMS); +} + +/** + * @tc.number : HksDsaMT02000 + * @tc.name : HksDsaMT02000 + * @tc.desc : Test huks Verify (1024/SHA384withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT02000, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_02000_PARAMS); +} + +/** + * @tc.number : HksDsaMT02100 + * @tc.name : HksDsaMT02100 + * @tc.desc : Test huks generate key (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT02100, TestSize.Level0) +{ + GenerateKeyTestCase(HKS_DSA_MT_02100_PARAMS); +} + +/** + * @tc.number : HksDsaMT02200 + * @tc.name : HksDsaMT02200 + * @tc.desc : Test huks sign (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT02200, TestSize.Level0) +{ + SignLocalTestCase(HKS_DSA_MT_02200_PARAMS); +} + +/** + * @tc.number : HksDsaMT02300 + * @tc.name : HksDsaMT02300 + * @tc.desc : Test huks sign (1024/SHA512withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT02300, TestSize.Level0) +{ + SignServiceTestCase(HKS_DSA_MT_02300_PARAMS); +} + +/** + * @tc.number : HksDsaMT02400 + * @tc.name : HksDsaMT02400 + * @tc.desc : Test huks Verify (1024/SHA512withDSA/TEMP) + */ +HWTEST_F(HksDsaMt, HksDsaMT02400, TestSize.Level0) +{ + VerifyLocalTestCase(HKS_DSA_MT_02400_PARAMS); +} + +/** + * @tc.number : HksDsaMT02500 + * @tc.name : HksDsaMT02500 + * @tc.desc : Test huks Verify (1024/SHA512withDSA/PERSISTENT) + */ +HWTEST_F(HksDsaMt, HksDsaMT02500, TestSize.Level0) +{ + VerifyServiceTestCase(HKS_DSA_MT_02500_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_test_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_test_mt.cpp deleted file mode 100755 index d40c6277..00000000 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_dsa_test_mt.cpp +++ /dev/null @@ -1,1730 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hks_openssl_dsa_sign_test_mt.h" - -#include - -#include "hks_api.h" -#include "hks_mem.h" - -using namespace testing::ext; -namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for DSA"; -const int SET_SIZE_4096 = 4096; -const int KEY_SIZE_1024 = 1024; -} // namespace - -class HksDsaTestMT : public testing::Test {}; - -static const struct HksParam DSA_00100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00100 - * @tc.name : HksDsaMtTest00100 - * @tc.desc : Test huks generate key (1024/SHA1withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00100_PARAMS, sizeof(DSA_00100_PARAMS) / sizeof(DSA_00100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA1), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_00200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00200 - * @tc.name : HksDsaMtTest00200 - * @tc.desc : Test huks sign (1024/SHA1withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00200_PARAMS, sizeof(DSA_00200_PARAMS) / sizeof(DSA_00200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA1), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_00300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00300 - * @tc.name : HksDsaMtTest00300 - * @tc.desc : Test huks sign (1024/SHA1withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00300_PARAMS, sizeof(DSA_00300_PARAMS) / sizeof(DSA_00300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslDsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); - - uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t dsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; - EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA1), 0); - - free(publicKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_00400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00400 - * @tc.name : HksDsaMtTest00400 - * @tc.desc : Test huks Verify (1024/SHA1withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00400, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00400_PARAMS, sizeof(DSA_00400_PARAMS) / sizeof(DSA_00400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_00500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00500 - * @tc.name : HksDsaMtTest00500 - * @tc.desc : Test huks Verify (1024/SHA1withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00500_PARAMS, sizeof(DSA_00500_PARAMS) / sizeof(DSA_00500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslDsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - DsaGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA1), 0); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); -#else - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); -#endif - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslDsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_00600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00600 - * @tc.name : HksDsaMtTest00600 - * @tc.desc : Test huks generate key (1024/SHA224withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00600, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00600_PARAMS, sizeof(DSA_00600_PARAMS) / sizeof(DSA_00600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA224), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_00700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00700 - * @tc.name : HksDsaMtTest00700 - * @tc.desc : Test huks sign (1024/SHA224withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00700, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00700_PARAMS, sizeof(DSA_00700_PARAMS) / sizeof(DSA_00700_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA224), 0); - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_00800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00800 - * @tc.name : HksDsaMtTest00800 - * @tc.desc : Test huks sign (1024/SHA224withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00800_PARAMS, sizeof(DSA_00800_PARAMS) / sizeof(DSA_00800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslDsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); - - uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t dsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; - EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA224), 0); - - free(publicKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_00900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest00900 - * @tc.name : HksDsaMtTest00900 - * @tc.desc : Test huks Verify (1024/SHA224withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest00900, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_00900_PARAMS, sizeof(DSA_00900_PARAMS) / sizeof(DSA_00900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01000 - * @tc.name : HksDsaMtTest01000 - * @tc.desc : Test huks Verify (1024/SHA224withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01000_PARAMS, sizeof(DSA_01000_PARAMS) / sizeof(DSA_01000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslDsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - DsaGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA224), 0); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); -#else - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); -#endif - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslDsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01100 - * @tc.name : HksDsaMtTest01100 - * @tc.desc : Test huks generate key (1024/SHA256withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01100_PARAMS, sizeof(DSA_01100_PARAMS) / sizeof(DSA_01100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA256), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01200 - * @tc.name : HksDsaMtTest01200 - * @tc.desc : Test huks sign (1024/SHA256withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01200_PARAMS, sizeof(DSA_01200_PARAMS) / sizeof(DSA_01200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA256), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01300 - * @tc.name : HksDsaMtTest01300 - * @tc.desc : Test huks sign (1024/SHA256withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01300_PARAMS, sizeof(DSA_01300_PARAMS) / sizeof(DSA_01300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslDsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); - - uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t dsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; - EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA256), 0); - - free(publicKey.data); - free(signData.data); - -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01400 - * @tc.name : HksDsaMtTest01400 - * @tc.desc : Test huks Verify (1024/SHA256withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01400, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01400_PARAMS, sizeof(DSA_01400_PARAMS) / sizeof(DSA_01400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01500 - * @tc.name : HksDsaMtTest01500 - * @tc.desc : Test huks Verify (1024/SHA256withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01500_PARAMS, sizeof(DSA_01500_PARAMS) / sizeof(DSA_01500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslDsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - DsaGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA256), 0); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); -#else - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); -#endif - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslDsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01600 - * @tc.name : HksDsaMtTest01600 - * @tc.desc : Test huks generate key (1024/SHA384withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01600, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01600_PARAMS, sizeof(DSA_01600_PARAMS) / sizeof(DSA_01600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA384), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01700 - * @tc.name : HksDsaMtTest01700 - * @tc.desc : Test huks sign (1024/SHA384withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01700, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01700_PARAMS, sizeof(DSA_01700_PARAMS) / sizeof(DSA_01700_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA384), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01800 - * @tc.name : HksDsaMtTest01800 - * @tc.desc : Test huks sign (1024/SHA384withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01800_PARAMS, sizeof(DSA_01800_PARAMS) / sizeof(DSA_01800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslDsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); - - uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t dsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; - EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA384), 0); - - free(publicKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_01900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest01900 - * @tc.name : HksDsaMtTest01900 - * @tc.desc : Test huks Verify (1024/SHA384withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest01900, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_01900_PARAMS, sizeof(DSA_01900_PARAMS) / sizeof(DSA_01900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_02000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest02000 - * @tc.name : HksDsaMtTest02000 - * @tc.desc : Test huks Verify (1024/SHA384withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest02000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, DSA_02000_PARAMS, sizeof(DSA_02000_PARAMS) / sizeof(DSA_02000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslDsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - DsaGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA384), 0); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); -#else - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); -#endif - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslDsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_02100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest02100 - * @tc.name : HksDsaMtTest02100 - * @tc.desc : Test huks generate key (1024/SHA512withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest02100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_02100_PARAMS, sizeof(DSA_02100_PARAMS) / sizeof(DSA_02100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA512), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_02200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest02200 - * @tc.name : HksDsaMtTest02200 - * @tc.desc : Test huks sign (1024/SHA512withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest02200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_02200_PARAMS, sizeof(DSA_02200_PARAMS) / sizeof(DSA_02200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA512), 0); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_02300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest02300 - * @tc.name : HksDsaMtTest02300 - * @tc.desc : Test huks sign (1024/SHA512withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest02300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_02300_PARAMS, sizeof(DSA_02300_PARAMS) / sizeof(DSA_02300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslDsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslDsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslDsaKeyInfo = { opensslDsaKeyLen, opensslDsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslDsaKeyInfo), HKS_SUCCESS); - - uint8_t dsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t dsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob dsaPublicKeyInfo = { dsaPublicKeyLen, dsaPublicKey }; - EXPECT_EQ(X509ToDsaPublicKey(&opensslDsaKeyInfo, &dsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = dsaPublicKeyInfo.size, .data = (uint8_t *)malloc(dsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, dsaPublicKeyInfo.data, dsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyDsa(&plainText, &signData, &publicKey, HKS_DIGEST_SHA512), 0); - - free(publicKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_02400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest02400 - * @tc.name : HksDsaMtTest02400 - * @tc.desc : Test huks Verify (1024/SHA512withDSA/TEMP) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest02400, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, DSA_02400_PARAMS, sizeof(DSA_02400_PARAMS) / sizeof(DSA_02400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_ERROR_NOT_SUPPORTED); -#else - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &privateKey, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(publicKey.data); - free(privateKey.data); - free(signData.data); -#endif - free(paramSetOut); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam DSA_02500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - -/** - * @tc.number : HksDsaMtTest02500 - * @tc.name : HksDsaMtTest02500 - * @tc.desc : Test huks Verify (1024/SHA512withDSA/PERSISTENT) - */ -HWTEST_F(HksDsaTestMT, HksDsaMtTest02500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, DSA_02500_PARAMS, sizeof(DSA_02500_PARAMS) / sizeof(DSA_02500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslDsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslDsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateDsaKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - DsaGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveDsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslDsaKeyInfo); - - EXPECT_EQ(OpensslSignDsa(&plainText, &signData, &opensslDsaKeyInfo, HKS_DIGEST_SHA512), 0); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_ERROR_INVALID_ARGUMENT); -#else - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); -#endif - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslDsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} -} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt.cpp new file mode 100755 index 00000000..b9d2636f --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt.cpp @@ -0,0 +1,753 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_ecc_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; + +const char ECC_KEY[] = "This is a ECC key"; + +const TestCaseParams HUKS_ECC_KEY_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_01900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_KEY_MT_02400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace + +class HksEccKeyMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(ECC_KEY), (uint8_t *)ECC_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST); + + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_521) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), testCaseParams.generateKeyResult); + HksParam *priParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)HksMalloc(priParam->blob.size) }; + (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)HksMalloc(pubParam->blob.size) }; + (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); + + HksBlob message = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&priKey, digest, &message, &signature), testCaseParams.signResult); + EXPECT_EQ(EcdsaVerify(&pubKey, digest, &message, &signature), testCaseParams.verifyResult); + + HksFreeParamSet(¶mInSet); + HksFree(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + HksFree(priKey.data); + HksFree(pubKey.data); + HksFree(signature.data); + } +}; + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00100 + * @tc.name : HksEccKeyMt00100 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00100_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00200 + * @tc.name : HksEccKeyMt00200 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00200_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00300 + * @tc.name : HksEccKeyMt00300 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00300_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00400 + * @tc.name : HksEccKeyMt00400 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00400_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00500 + * @tc.name : HksEccKeyMt00500 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00500_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00600 + * @tc.name : HksEccKeyMt00600 + * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00600_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00700 + * @tc.name : HksEccKeyMt00700 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00700_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00800 + * @tc.name : HksEccKeyMt00800 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00800_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt00900 + * @tc.name : HksEccKeyMt00900 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_00900_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01000 + * @tc.name : HksEccKeyMt01000 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01000_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01100 + * @tc.name : HksEccKeyMt01100 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01100_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01200 + * @tc.name : HksEccKeyMt01200 + * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01200_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01300 + * @tc.name : HksEccKeyMt01300 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01300_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01400 + * @tc.name : HksEccKeyMt01400 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01400_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01500 + * @tc.name : HksEccKeyMt01500 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01500_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01600 + * @tc.name : HksEccKeyMt01600 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01600_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01700 + * @tc.name : HksEccKeyMt01700 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01700_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01800 + * @tc.name : HksEccKeyMt01800 + * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01800_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt01900 + * @tc.name : HksEccKeyMt01900 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-NONE algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt01900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_01900_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02000 + * @tc.name : HksEccKeyMt02000 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA1 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02000_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02100 + * @tc.name : HksEccKeyMt02100 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA224 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02100_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02200 + * @tc.name : HksEccKeyMt02200 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA256 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02200_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02300 + * @tc.name : HksEccKeyMt02300 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA384 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02300_PARAMS); +} + +/** + * @tc.number : HksEccKeyMt.HksEccKeyMt02400 + * @tc.name : HksEccKeyMt02400 + * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using + * ECC/DIGEST-SHA512 algorithm + */ +HWTEST_F(HksEccKeyMt, HksEccKeyMt02400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_KEY_MT_02400_PARAMS); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt_test.cpp deleted file mode 100755 index fe00ad37..00000000 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_key_mt_test.cpp +++ /dev/null @@ -1,1497 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hks_openssl_ecc_mt_test.h" - -#include - -#include "hks_api.h" -#include "hks_mem.h" -#include "hks_param.h" - -using namespace testing::ext; -namespace { -namespace { -const char ECC_224KEY[] = "This is a ECC_224 key"; -const char ECC_256KEY[] = "This is a ECC_256 key"; -const char ECC_384KEY[] = "This is a ECC_384 key"; -const char ECC_521KEY[] = "This is a ECC_521 key"; -} // namespace -class HksEccKeyMtTest : public testing::Test {}; - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00100 - * @tc.name : HksEccKeyMtTest00100 - * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-NONE algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00200 - * @tc.name : HksEccKeyMtTest00200 - * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA1 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00300 - * @tc.name : HksEccKeyMtTest00300 - * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA224 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00400 - * @tc.name : HksEccKeyMtTest00400 - * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA256 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00500 - * @tc.name : HksEccKeyMtTest00500 - * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA384 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00600 - * @tc.name : HksEccKeyMtTest00600 - * @tc.desc : Huks generates ECC224 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA512 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_224) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00700 - * @tc.name : HksEccKeyMtTest00700 - * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-NONE algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00800 - * @tc.name : HksEccKeyMtTest00800 - * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA1 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest00900 - * @tc.name : HksEccKeyMtTest00900 - * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA224 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest00900, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01000 - * @tc.name : HksEccKeyMtTest01000 - * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA256 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01100 - * @tc.name : HksEccKeyMtTest01100 - * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA384 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01200 - * @tc.name : HksEccKeyMtTest01200 - * @tc.desc : Huks generates ECC256 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA512 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_256, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_256) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01300 - * @tc.name : HksEccKeyMtTest01300 - * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-NONE algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01400 - * @tc.name : HksEccKeyMtTest01400 - * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA1 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01500 - * @tc.name : HksEccKeyMtTest01500 - * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA224 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01600 - * @tc.name : HksEccKeyMtTest01600 - * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA256 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01700 - * @tc.name : HksEccKeyMtTest01700 - * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA384 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01800 - * @tc.name : HksEccKeyMtTest01800 - * @tc.desc : Huks generates ECC384 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA512 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_384, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_384) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest01900 - * @tc.name : HksEccKeyMtTest01900 - * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-NONE algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest01900, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02000 - * @tc.name : HksEccKeyMtTest02000 - * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA1 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02100 - * @tc.name : HksEccKeyMtTest02100 - * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA224 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02200 - * @tc.name : HksEccKeyMtTest02200 - * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA256 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02300 - * @tc.name : HksEccKeyMtTest02300 - * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA384 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccKeyMtTest.HksEccKeyMtTest02400 - * @tc.name : HksEccKeyMtTest02400 - * @tc.desc : Huks generates ECC521 bit key, which can be successfully used for OpenSSL sign/verify using - * ECC/DIGEST-SHA512 algorithm - */ -HWTEST_F(HksEccKeyMtTest, HksEccKeyMtTest02400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, - .blob = { .size = HKS_ECC_KEY_SIZE_521, .data = (uint8_t *)malloc(HKS_ECC_KEY_SIZE_521) } }; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - HksParam *priParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); - HksBlob priKey = { .size = priParam->blob.size, .data = (uint8_t *)malloc(priParam->blob.size) }; - (void)memcpy_s(priKey.data, priParam->blob.size, priParam->blob.data, priParam->blob.size); - - HksParam *pubParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); - HksBlob pubKey = { .size = pubParam->blob.size, .data = (uint8_t *)malloc(pubParam->blob.size) }; - (void)memcpy_s(pubKey.data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&priKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(localKey.blob.data); - HksFreeParamSet(¶mOutSet); - free(priKey.data); - free(pubKey.data); - free(signature.data); -} -} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt.cpp similarity index 36% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt_test.cpp rename to interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt.cpp index f6ad1b4a..d6ae913a 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt_test.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_sign_mt.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "hks_openssl_ecc_mt_test.h" +#include "openssl_ecc_helper.h" #include @@ -22,29 +22,24 @@ #include "hks_param.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char ECC_224KEY[] = "This is a ECC_224 key"; -const char ECC_256KEY[] = "This is a ECC_256 key"; -const char ECC_384KEY[] = "This is a ECC_384 key"; -const char ECC_521KEY[] = "This is a ECC_521 key"; -} // namespace -class HksEccSignMtTest : public testing::Test {}; +struct TestCaseParams { + std::vector params; + std::string hexData; -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00100 - * @tc.name : HksEccSignMtTest00100 - * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); +const char ECC_KEY[] = "This is a ECC key"; - struct HksParam tmpParams[] = { +const TestCaseParams HUKS_ECC_SIGN_MT_00100_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -52,43 +47,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00100, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00200 - * @tc.name : HksEccSignMtTest00200 - * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00200_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -96,43 +63,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00200, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00300 - * @tc.name : HksEccSignMtTest00300 - * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00300_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -140,43 +79,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00300, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00400 - * @tc.name : HksEccSignMtTest00400 - * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00400_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -184,43 +95,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00400, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00500 - * @tc.name : HksEccSignMtTest00500 - * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00500_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -228,43 +111,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00500, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00600 - * @tc.name : HksEccSignMtTest00600 - * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00600_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -272,43 +127,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00600, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00700 - * @tc.name : HksEccSignMtTest00700 - * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00700_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, @@ -316,43 +143,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00700, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00800 - * @tc.name : HksEccSignMtTest00800 - * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00800_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, @@ -360,43 +159,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00800, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest00900 - * @tc.name : HksEccSignMtTest00900 - * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00900, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_00900_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, @@ -404,43 +175,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest00900, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01000 - * @tc.name : HksEccSignMtTest01000 - * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01000_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, @@ -448,43 +191,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01000, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01100 - * @tc.name : HksEccSignMtTest01100 - * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01100_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, @@ -492,43 +207,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01100, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01200 - * @tc.name : HksEccSignMtTest01200 - * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01200_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, @@ -536,43 +223,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01200, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01300 - * @tc.name : HksEccSignMtTest01300 - * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01300_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, @@ -580,43 +239,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01300, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01400 - * @tc.name : HksEccSignMtTest01400 - * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01400_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, @@ -624,43 +255,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01400, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01500 - * @tc.name : HksEccSignMtTest01500 - * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01500_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, @@ -668,43 +271,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01500, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01600 - * @tc.name : HksEccSignMtTest01600 - * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01600_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, @@ -712,43 +287,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01600, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01700 - * @tc.name : HksEccSignMtTest01700 - * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01700_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, @@ -756,43 +303,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01700, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01800 - * @tc.name : HksEccSignMtTest01800 - * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01800_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, @@ -800,43 +319,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01800, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest01900 - * @tc.name : HksEccSignMtTest01900 - * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01900, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_01900_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, @@ -844,43 +335,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest01900, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02000 - * @tc.name : HksEccSignMtTest02000 - * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02000_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, @@ -888,43 +351,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02000, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02100 - * @tc.name : HksEccSignMtTest02100 - * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02100, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02100_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, @@ -932,43 +367,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02100, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02200 - * @tc.name : HksEccSignMtTest02200 - * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02200_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, @@ -976,43 +383,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02200, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02300 - * @tc.name : HksEccSignMtTest02300 - * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02300_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, @@ -1020,43 +399,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02300, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02400 - * @tc.name : HksEccSignMtTest02400 - * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02400_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, @@ -1064,43 +415,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02400, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02500 - * @tc.name : HksEccSignMtTest02500 - * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02500_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -1108,46 +431,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02500, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02600 - * @tc.name : HksEccSignMtTest02600 - * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02600_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -1155,46 +447,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02600, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02700 - * @tc.name : HksEccSignMtTest02700 - * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02700, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02700_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -1202,46 +463,15 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02700, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); -} - -/** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02800 - * @tc.name : HksEccSignMtTest02800 - * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification - */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02800_PARAMS = { + .params = { { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, @@ -1249,969 +479,922 @@ HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02800, TestSize.Level1) { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_02900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_03900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_SIGN_MT_04800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); +class HksEccSignMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { (uint32_t)strlen(ECC_KEY), (uint8_t *)ECC_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST); + uint32_t storage = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_STORAGE_FLAG); + if (storage == HKS_STORAGE_TEMP) { + authId = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + } + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + + if (storage == HKS_STORAGE_TEMP) { + uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE); + EXPECT_EQ(ECCGenerateKey(keySize, &authId), testCaseParams.generateKeyResult); + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + } else if (storage == HKS_STORAGE_PERSISTENT) { + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), testCaseParams.generateKeyResult); + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); + } + + HksBlob message = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), testCaseParams.signResult); + EXPECT_EQ(EcdsaVerify(&pubKey, digest, &message, &signature), testCaseParams.verifyResult); + + if (storage == HKS_STORAGE_TEMP) { + HksFree(authId.data); + } + HksFreeParamSet(¶mInSet); + HksFree(pubKey.data); + HksFree(x509Key.data); + HksFree(signature.data); + } +}; - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt00100 + * @tc.name : HksEccSignMt00100 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00100_PARAMS); +} - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; +/** + * @tc.number : HksEccSignMt.HksEccSignMt00200 + * @tc.name : HksEccSignMt00200 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00200_PARAMS); +} - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt00300 + * @tc.name : HksEccSignMt00300 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00300_PARAMS); +} - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); +/** + * @tc.number : HksEccSignMt.HksEccSignMt00400 + * @tc.name : HksEccSignMt00400 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00400_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest02900 - * @tc.name : HksEccSignMtTest02900 - * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * @tc.number : HksEccSignMt.HksEccSignMt00500 + * @tc.name : HksEccSignMt00500 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest02900, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt00500, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + RunTestCase(HUKS_ECC_SIGN_MT_00500_PARAMS); +} - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); +/** + * @tc.number : HksEccSignMt.HksEccSignMt00600 + * @tc.name : HksEccSignMt00600 + * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00600_PARAMS); +} - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; +/** + * @tc.number : HksEccSignMt.HksEccSignMt00700 + * @tc.name : HksEccSignMt00700 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00700_PARAMS); +} - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); +/** + * @tc.number : HksEccSignMt.HksEccSignMt00800 + * @tc.name : HksEccSignMt00800 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00800_PARAMS); +} - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt00900 + * @tc.name : HksEccSignMt00900 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_00900_PARAMS); +} - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt01000 + * @tc.name : HksEccSignMt01000 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01000_PARAMS); +} - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; +/** + * @tc.number : HksEccSignMt.HksEccSignMt01100 + * @tc.name : HksEccSignMt01100 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01100_PARAMS); +} - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt01200 + * @tc.name : HksEccSignMt01200 + * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01200_PARAMS); +} - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); +/** + * @tc.number : HksEccSignMt.HksEccSignMt01300 + * @tc.name : HksEccSignMt01300 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01300_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03000 - * @tc.name : HksEccSignMtTest03000 - * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + * @tc.number : HksEccSignMt.HksEccSignMt01400 + * @tc.name : HksEccSignMt01400 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03000, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt01400, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; + RunTestCase(HUKS_ECC_SIGN_MT_01400_PARAMS); +} - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); +/** + * @tc.number : HksEccSignMt.HksEccSignMt01500 + * @tc.name : HksEccSignMt01500 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01500_PARAMS); +} - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; +/** + * @tc.number : HksEccSignMt.HksEccSignMt01600 + * @tc.name : HksEccSignMt01600 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01600_PARAMS); +} - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); +/** + * @tc.number : HksEccSignMt.HksEccSignMt01700 + * @tc.name : HksEccSignMt01700 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01700_PARAMS); +} - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt01800 + * @tc.name : HksEccSignMt01800 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01800_PARAMS); +} - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt01900 + * @tc.name : HksEccSignMt01900 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt01900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_01900_PARAMS); +} - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; +/** + * @tc.number : HksEccSignMt.HksEccSignMt02000 + * @tc.name : HksEccSignMt02000 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02000_PARAMS); +} - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt02100 + * @tc.name : HksEccSignMt02100 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02100_PARAMS); +} - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); +/** + * @tc.number : HksEccSignMt.HksEccSignMt02200 + * @tc.name : HksEccSignMt02200 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02200, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02200_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03100 - * @tc.name : HksEccSignMtTest03100 - * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with - * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + * @tc.number : HksEccSignMt.HksEccSignMt02300 + * @tc.name : HksEccSignMt02300 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03100, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt02300, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; + RunTestCase(HUKS_ECC_SIGN_MT_02300_PARAMS); +} - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); +/** + * @tc.number : HksEccSignMt.HksEccSignMt02400 + * @tc.name : HksEccSignMt02400 + * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02400_PARAMS); +} - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; +/** + * @tc.number : HksEccSignMt.HksEccSignMt02500 + * @tc.name : HksEccSignMt02500 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02500_PARAMS); +} - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); +/** + * @tc.number : HksEccSignMt.HksEccSignMt02600 + * @tc.name : HksEccSignMt02600 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02600, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02600_PARAMS); +} - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt02700 + * @tc.name : HksEccSignMt02700 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02700, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02700_PARAMS); +} - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt02800 + * @tc.name : HksEccSignMt02800 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02800, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02800_PARAMS); +} - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; +/** + * @tc.number : HksEccSignMt.HksEccSignMt02900 + * @tc.name : HksEccSignMt02900 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt02900, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_02900_PARAMS); +} - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); +/** + * @tc.number : HksEccSignMt.HksEccSignMt03000 + * @tc.name : HksEccSignMt03000 + * @tc.desc : Huks generates an ecc224 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03000, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03000_PARAMS); +} - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); +/** + * @tc.number : HksEccSignMt.HksEccSignMt03100 + * @tc.name : HksEccSignMt03100 + * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with + * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification + */ +HWTEST_F(HksEccSignMt, HksEccSignMt03100, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_SIGN_MT_03100_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03200 - * @tc.name : HksEccSignMtTest03200 + * @tc.number : HksEccSignMt.HksEccSignMt03200 + * @tc.name : HksEccSignMt03200 * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03200, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt03200, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_03200_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03300 - * @tc.name : HksEccSignMtTest03300 + * @tc.number : HksEccSignMt.HksEccSignMt03300 + * @tc.name : HksEccSignMt03300 * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03300, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt03300, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_03300_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03400 - * @tc.name : HksEccSignMtTest03400 + * @tc.number : HksEccSignMt.HksEccSignMt03400 + * @tc.name : HksEccSignMt03400 * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03400, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt03400, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_03400_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03500 - * @tc.name : HksEccSignMtTest03500 + * @tc.number : HksEccSignMt.HksEccSignMt03500 + * @tc.name : HksEccSignMt03500 * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03500, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt03500, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_03500_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03600 - * @tc.name : HksEccSignMtTest03600 + * @tc.number : HksEccSignMt.HksEccSignMt03600 + * @tc.name : HksEccSignMt03600 * @tc.desc : Huks generates an ecc256 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03600, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt03600, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_03600_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03700 - * @tc.name : HksEccSignMtTest03700 + * @tc.number : HksEccSignMt.HksEccSignMt03700 + * @tc.name : HksEccSignMt03700 * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03700, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt03700, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_03700_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03800 - * @tc.name : HksEccSignMtTest03800 + * @tc.number : HksEccSignMt.HksEccSignMt03800 + * @tc.name : HksEccSignMt03800 * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03800, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt03800, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_03800_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest03900 - * @tc.name : HksEccSignMtTest03900 + * @tc.number : HksEccSignMt.HksEccSignMt03900 + * @tc.name : HksEccSignMt03900 * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest03900, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt03900, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_03900_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04000 - * @tc.name : HksEccSignMtTest04000 + * @tc.number : HksEccSignMt.HksEccSignMt04000 + * @tc.name : HksEccSignMt04000 * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04000, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04000, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04000_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04100 - * @tc.name : HksEccSignMtTest04100 + * @tc.number : HksEccSignMt.HksEccSignMt04100 + * @tc.name : HksEccSignMt04100 * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04100, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04100, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04100_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04200 - * @tc.name : HksEccSignMtTest04200 + * @tc.number : HksEccSignMt.HksEccSignMt04200 + * @tc.name : HksEccSignMt04200 * @tc.desc : Huks generates an ecc384 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04200, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04200, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04200_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04300 - * @tc.name : HksEccSignMtTest04300 + * @tc.number : HksEccSignMt.HksEccSignMt04300 + * @tc.name : HksEccSignMt04300 * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with * ECC/DIGEST-NONE algorithm, and OpenSSL uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04300, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04300, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04300_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04400 - * @tc.name : HksEccSignMtTest04400 + * @tc.number : HksEccSignMt.HksEccSignMt04400 + * @tc.name : HksEccSignMt04400 * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA1 algorithm, and OpenSSL uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04400, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04400, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04400_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04500 - * @tc.name : HksEccSignMtTest04500 + * @tc.number : HksEccSignMt.HksEccSignMt04500 + * @tc.name : HksEccSignMt04500 * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA224 algorithm, and OpenSSL uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04500, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04500, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04500_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04600 - * @tc.name : HksEccSignMtTest04600 + * @tc.number : HksEccSignMt.HksEccSignMt04600 + * @tc.name : HksEccSignMt04600 * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA256 algorithm, and OpenSSL uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04600, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04600, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04600_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04700 - * @tc.name : HksEccSignMtTest04700 + * @tc.number : HksEccSignMt.HksEccSignMt04700 + * @tc.name : HksEccSignMt04700 * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA384 algorithm, and OpenSSL uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04700, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04700, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04700_PARAMS); } /** - * @tc.number : HksEccSignMtTest.HksEccSignMtTest04800 - * @tc.name : HksEccSignMtTest04800 + * @tc.number : HksEccSignMt.HksEccSignMt04800 + * @tc.name : HksEccSignMt04800 * @tc.desc : Huks generates an ecc521 bit key, which can be successfully used for huks signing with * ECC/DIGEST-SHA512 algorithm, and OpenSSL uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccSignMtTest, HksEccSignMtTest04800, TestSize.Level1) +HWTEST_F(HksEccSignMt, HksEccSignMt04800, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(X509ToHksBlob(&x509Key, &pubKey), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(HksSign(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - EXPECT_EQ(EcdsaVerify(&pubKey, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(x509Key.data); - free(pubKey.data); - free(signature.data); + RunTestCase(HUKS_ECC_SIGN_MT_04800_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt.cpp similarity index 35% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt_test.cpp rename to interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt.cpp index cf2e3858..cf902b60 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt_test.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_ecc_verify_mt.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "hks_openssl_ecc_mt_test.h" +#include "openssl_ecc_helper.h" #include @@ -22,2173 +22,1375 @@ #include "hks_param.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char ECC_224KEY[] = "This is a ECC_224 key"; -const char ECC_256KEY[] = "This is a ECC_256 key"; -const char ECC_384KEY[] = "This is a ECC_384 key"; -const char ECC_521KEY[] = "This is a ECC_521 key"; +struct TestCaseParams { + std::vector params; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode signResult; + HksErrorCode verifyResult; +}; const char PUB_KEY[] = "This is a public key"; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_01900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_02900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_03900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_ECC_VERIFY_MT_04800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; } // namespace -class HksEccVerifyMtTest : public testing::Test {}; + +class HksEccVerifyMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams) + { + struct HksBlob authId = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST); + uint32_t storage = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_STORAGE_FLAG); + + struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + + uint32_t keySize = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_SIZE); + EXPECT_EQ(ECCGenerateKey(keySize, &authId), testCaseParams.generateKeyResult); + EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); + + HksBlob message = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(ECC_MESSAGE_SIZE) }; + + EXPECT_EQ(EcdsaSign(&authId, digest, &message, &signature), testCaseParams.signResult); + + if (storage == HKS_STORAGE_TEMP) { + EXPECT_EQ(HksVerify(&pubKey, paramInSet, &message, &signature), testCaseParams.verifyResult); + } else if (storage == HKS_STORAGE_PERSISTENT) { + HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)HksMalloc(ECC_KEY_SIZE) }; + EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); + struct HksBlob pubId = { (uint32_t)strlen(PUB_KEY), (uint8_t *)PUB_KEY }; + EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); + EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), testCaseParams.verifyResult); + HksFree(x509Key.data); + } + + HksFree(authId.data); + HksFreeParamSet(¶mInSet); + HksFree(pubKey.data); + HksFree(signature.data); + } +}; /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00100 - * @tc.name : HksEccVerifyMtTest00100 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00100 + * @tc.name : HksEccVerifyMt00100 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00100, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00100, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00100_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00200 - * @tc.name : HksEccVerifyMtTest00200 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00200 + * @tc.name : HksEccVerifyMt00200 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00200, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00200, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00200_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00300 - * @tc.name : HksEccVerifyMtTest00300 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00300 + * @tc.name : HksEccVerifyMt00300 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00300, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00300, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00300_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00400 - * @tc.name : HksEccVerifyMtTest00400 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00400 + * @tc.name : HksEccVerifyMt00400 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00400, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00400, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00400_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00500 - * @tc.name : HksEccVerifyMtTest00500 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00500 + * @tc.name : HksEccVerifyMt00500 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00500, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00500, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00500_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00600 - * @tc.name : HksEccVerifyMtTest00600 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00600 + * @tc.name : HksEccVerifyMt00600 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00600, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00600, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00600_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00700 - * @tc.name : HksEccVerifyMtTest00700 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00700 + * @tc.name : HksEccVerifyMt00700 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00700, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00700, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00700_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00800 - * @tc.name : HksEccVerifyMtTest00800 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00800 + * @tc.name : HksEccVerifyMt00800 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00800, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00800, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00800_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest00900 - * @tc.name : HksEccVerifyMtTest00900 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt00900 + * @tc.name : HksEccVerifyMt00900 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest00900, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt00900, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_00900_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01000 - * @tc.name : HksEccVerifyMtTest01000 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01000 + * @tc.name : HksEccVerifyMt01000 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01000, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01000, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_01000_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01100 - * @tc.name : HksEccVerifyMtTest01100 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01100 + * @tc.name : HksEccVerifyMt01100 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01100, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01100, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_01100_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01200 - * @tc.name : HksEccVerifyMtTest01200 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01200 + * @tc.name : HksEccVerifyMt01200 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01200, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01200, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_01200_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01300 - * @tc.name : HksEccVerifyMtTest01300 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01300 + * @tc.name : HksEccVerifyMt01300 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01300, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); -} - -/** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01400 - * @tc.name : HksEccVerifyMtTest01400 - * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with - * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification - */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01400, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01300, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_01300_PARAMS); } -/** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01500 - * @tc.name : HksEccVerifyMtTest01500 - * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with - * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification - */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01500, TestSize.Level1) -{ - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01400 + * @tc.name : HksEccVerifyMt01400 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01400_PARAMS); +} - HksFreeParamSet(¶mInSet); - free(signature.data); +/** + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01500 + * @tc.name : HksEccVerifyMt01500 + * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with + * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification + */ +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_ECC_VERIFY_MT_01500_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01600 - * @tc.name : HksEccVerifyMtTest01600 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01600 + * @tc.name : HksEccVerifyMt01600 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01600, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01600, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_01600_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01700 - * @tc.name : HksEccVerifyMtTest01700 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01700 + * @tc.name : HksEccVerifyMt01700 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01700, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01700, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_01700_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01800 - * @tc.name : HksEccVerifyMtTest01800 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01800 + * @tc.name : HksEccVerifyMt01800 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01800, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01800, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_01800_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest01900 - * @tc.name : HksEccVerifyMtTest01900 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt01900 + * @tc.name : HksEccVerifyMt01900 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest01900, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt01900, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_01900_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02000 - * @tc.name : HksEccVerifyMtTest02000 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02000 + * @tc.name : HksEccVerifyMt02000 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02000, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02000, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02000_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02100 - * @tc.name : HksEccVerifyMtTest02100 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02100 + * @tc.name : HksEccVerifyMt02100 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02100, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02100, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02100_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02200 - * @tc.name : HksEccVerifyMtTest02200 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02200 + * @tc.name : HksEccVerifyMt02200 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02200, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02200, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02200_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02300 - * @tc.name : HksEccVerifyMtTest02300 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02300 + * @tc.name : HksEccVerifyMt02300 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02300, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02300, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02300_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02400 - * @tc.name : HksEccVerifyMtTest02400 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02400 + * @tc.name : HksEccVerifyMt02400 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02400, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02400, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02400_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02500 - * @tc.name : HksEccVerifyMtTest02500 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02500 + * @tc.name : HksEccVerifyMt02500 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02500, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02500, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02500_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02600 - * @tc.name : HksEccVerifyMtTest02600 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02600 + * @tc.name : HksEccVerifyMt02600 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02600, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02600, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02600_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02700 - * @tc.name : HksEccVerifyMtTest02700 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02700 + * @tc.name : HksEccVerifyMt02700 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02700, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02700, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02700_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02800 - * @tc.name : HksEccVerifyMtTest02800 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02800 + * @tc.name : HksEccVerifyMt02800 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02800, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02800, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02800_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest02900 - * @tc.name : HksEccVerifyMtTest02900 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt02900 + * @tc.name : HksEccVerifyMt02900 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest02900, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt02900, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_02900_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03000 - * @tc.name : HksEccVerifyMtTest03000 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03000 + * @tc.name : HksEccVerifyMt03000 * @tc.desc : OpenSSL generates an ecc224 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03000, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03000, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_224KEY), (uint8_t *)ECC_224KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_224, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03000_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03100 - * @tc.name : HksEccVerifyMtTest03100 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03100 + * @tc.name : HksEccVerifyMt03100 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03100, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03100, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03100_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03200 - * @tc.name : HksEccVerifyMtTest03200 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03200 + * @tc.name : HksEccVerifyMt03200 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03200, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03200, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03200_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03300 - * @tc.name : HksEccVerifyMtTest03300 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03300 + * @tc.name : HksEccVerifyMt03300 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03300, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03300, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03300_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03400 - * @tc.name : HksEccVerifyMtTest03400 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03400 + * @tc.name : HksEccVerifyMt03400 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03400, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03400, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03400_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03500 - * @tc.name : HksEccVerifyMtTest03500 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03500 + * @tc.name : HksEccVerifyMt03500 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03500, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03500, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03500_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03600 - * @tc.name : HksEccVerifyMtTest03600 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03600 + * @tc.name : HksEccVerifyMt03600 * @tc.desc : OpenSSL generates an ecc256 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03600, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03600, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_256KEY), (uint8_t *)ECC_256KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_256, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03600_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03700 - * @tc.name : HksEccVerifyMtTest03700 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03700 + * @tc.name : HksEccVerifyMt03700 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03700, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03700, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03700_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03800 - * @tc.name : HksEccVerifyMtTest03800 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03800 + * @tc.name : HksEccVerifyMt03800 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03800, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03800, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03800_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest03900 - * @tc.name : HksEccVerifyMtTest03900 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt03900 + * @tc.name : HksEccVerifyMt03900 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest03900, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt03900, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_03900_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04000 - * @tc.name : HksEccVerifyMtTest04000 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04000 + * @tc.name : HksEccVerifyMt04000 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04000, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04000, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04000_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04100 - * @tc.name : HksEccVerifyMtTest04100 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04100 + * @tc.name : HksEccVerifyMt04100 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04100, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04100, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04100_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04200 - * @tc.name : HksEccVerifyMtTest04200 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04200 + * @tc.name : HksEccVerifyMt04200 * @tc.desc : OpenSSL generates an ecc384 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04200, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04200, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_384KEY), (uint8_t *)ECC_384KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_384, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04200_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04300 - * @tc.name : HksEccVerifyMtTest04300 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04300 + * @tc.name : HksEccVerifyMt04300 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-NONE algorithm, and huks uses ECC/DIGEST-NONE algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04300, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04300, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_NONE, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04300_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04400 - * @tc.name : HksEccVerifyMtTest04400 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04400 + * @tc.name : HksEccVerifyMt04400 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA1 algorithm, and huks uses ECC/DIGEST-SHA1 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04400, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04400, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA1, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04400_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04500 - * @tc.name : HksEccVerifyMtTest04500 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04500 + * @tc.name : HksEccVerifyMt04500 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA224 algorithm, and huks uses ECC/DIGEST-SHA224 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04500, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04500, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA224, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04500_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04600 - * @tc.name : HksEccVerifyMtTest04600 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04600 + * @tc.name : HksEccVerifyMt04600 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA256 algorithm, and huks uses ECC/DIGEST-SHA256 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04600, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04600, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA256, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04600_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04700 - * @tc.name : HksEccVerifyMtTest04700 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04700 + * @tc.name : HksEccVerifyMt04700 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA384 algorithm, and huks uses ECC/DIGEST-SHA384 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04700, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04700, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA384, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04700_PARAMS); } /** - * @tc.number : HksEccVerifyMtTest.HksEccVerifyMtTest04800 - * @tc.name : HksEccVerifyMtTest04800 + * @tc.number : HksEccVerifyMt.HksEccVerifyMt04800 + * @tc.name : HksEccVerifyMt04800 * @tc.desc : OpenSSL generates an ecc521 bit key, which can be successfully used for OpenSSL signing with * ECC/DIGEST-SHA512 algorithm, and huks uses ECC/DIGEST-SHA512 algorithm for verification */ -HWTEST_F(HksEccVerifyMtTest, HksEccVerifyMtTest04800, TestSize.Level1) +HWTEST_F(HksEccVerifyMt, HksEccVerifyMt04800, TestSize.Level0) { - struct HksBlob authId = { strlen(ECC_521KEY), (uint8_t *)ECC_521KEY }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - EXPECT_EQ(ECCGenerateKey(HKS_ECC_KEY_SIZE_521, &authId), ECC_SUCCESS); - - struct HksBlob pubKey = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(GetEccPubKey(&authId, &pubKey), ECC_SUCCESS); - - HksBlob x509Key = { .size = ECC_KEY_SIZE, .data = (uint8_t *)malloc(ECC_KEY_SIZE) }; - EXPECT_EQ(HksBlobToX509(&pubKey, &x509Key), ECC_SUCCESS); - struct HksBlob pubId = { strlen(PUB_KEY), (uint8_t *)PUB_KEY }; - EXPECT_EQ(HksImportKey(&pubId, paramInSet, &x509Key), HKS_SUCCESS); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; - HksBlob signature = { .size = ECC_MESSAGE_SIZE, .data = (uint8_t *)malloc(ECC_MESSAGE_SIZE) }; - - EXPECT_EQ(EcdsaSign(&authId, HKS_DIGEST_SHA512, &message, &signature), ECC_SUCCESS); - EXPECT_EQ(HksVerify(&pubId, paramInSet, &message, &signature), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(pubKey.data); - free(x509Key.data); - free(signature.data); + RunTestCase(HUKS_ECC_VERIFY_MT_04800_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt.cpp new file mode 100755 index 00000000..f6745784 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt.cpp @@ -0,0 +1,489 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "openssl_hmac_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +struct TestCaseParams { + std::vector params; + std::string hexData; + + HksErrorCode generateKeyResult; + HksErrorCode hmacResult; +}; + +const char HMAC_KEY[] = "This is a HMAC key"; + +const TestCaseParams HUKS_HMAC_MT_00100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00600_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00700_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00800_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_00900_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01000_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01100_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01200_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01300_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01400_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; + +const TestCaseParams HUKS_HMAC_MT_01500_PARAMS = { + .params = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }, + .hexData = "0123456789abcdef", + .generateKeyResult = HKS_SUCCESS, + .hmacResult = HKS_SUCCESS, +}; +} // namespace + +class HksHmacMt : public testing::Test { +protected: + uint32_t ReadValueByTag(std::vector params, uint32_t needTag) + { + for (auto testParams : params) { + if (testParams.tag == needTag) { + return testParams.uint32Param; + } + } + return 0; + } + + void RunTestCase(const TestCaseParams &testCaseParams, int32_t scenario) + { + struct HksBlob authId = { (uint32_t)strlen(HMAC_KEY), (uint8_t *)HMAC_KEY }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()); + HksBuildParamSet(¶mInSet); + + uint32_t digest = ReadValueByTag(testCaseParams.params, HKS_TAG_DIGEST); + uint32_t storage = ReadValueByTag(testCaseParams.params, HKS_TAG_KEY_STORAGE_FLAG); + + HksBlob message = { + .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0], + }; + HksBlob macForHuks = { .size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(HMAC_MESSAGE_SIZE) }; + + if (storage == HKS_STORAGE_TEMP) { + struct HksParamSet *paramOutSet = NULL; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HMAC_KEY_SIZE, .data = (uint8_t *)HksMalloc(HMAC_KEY_SIZE) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + if (scenario == 0) { + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), testCaseParams.generateKeyResult); + } else if (scenario == 1) { + EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), testCaseParams.generateKeyResult); + } + + HksParam *outParam = NULL; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); + HksBlob key = { .size = outParam->blob.size, .data = (uint8_t *)HksMalloc(outParam->blob.size) }; + (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); + HksBlob macMessage = { .size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(HMAC_MESSAGE_SIZE) }; + + EXPECT_EQ(HmacHmac(&key, digest, &message, &macMessage), testCaseParams.hmacResult); + EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), testCaseParams.hmacResult); + + EXPECT_EQ(macMessage.size, macForHuks.size); + EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); + if (scenario == 1) { + HksFree(authId.data); + } + HksFreeParamSet(¶mOutSet); + HksFree(localKey.blob.data); + HksFree(macMessage.data); + HksFree(key.data); + } else if (storage == HKS_STORAGE_PERSISTENT) { + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), testCaseParams.generateKeyResult); + EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), testCaseParams.hmacResult); + } + + HksFreeParamSet(¶mInSet); + HksFree(macForHuks.data); + } +}; + +/** + * @tc.number : HksHmacMt.HksHmacMt00100 + * @tc.name : HksHmacMt00100 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00100, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00100_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00200 + * @tc.name : HksHmacMt00200 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00200, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00200_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00300 + * @tc.name : HksHmacMt00300 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00300, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00300_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00400 + * @tc.name : HksHmacMt00400 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00400, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00400_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00500 + * @tc.name : HksHmacMt00500 + * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00500, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00500_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00600 + * @tc.name : HksHmacMt00600 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00600, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00600_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00700 + * @tc.name : HksHmacMt00700 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00700, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00700_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00800 + * @tc.name : HksHmacMt00800 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00800, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00800_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt00900 + * @tc.name : HksHmacMt00900 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt00900, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_00900_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01000 + * @tc.name : HksHmacMt01000 + * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01000, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01000_PARAMS, 1); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01100 + * @tc.name : HksHmacMt01100 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01100, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01100_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01200 + * @tc.name : HksHmacMt01200 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01200, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01200_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01300 + * @tc.name : HksHmacMt01300 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01300, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01300_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01400 + * @tc.name : HksHmacMt01400 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01400, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01400_PARAMS, 0); +} + +/** + * @tc.number : HksHmacMt.HksHmacMt01500 + * @tc.name : HksHmacMt01500 + * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation + */ +HWTEST_F(HksHmacMt, HksHmacMt01500, TestSize.Level0) +{ + RunTestCase(HUKS_HMAC_MT_01500_PARAMS, 0); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp deleted file mode 100755 index e365eb65..00000000 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_hmac_mt_test.cpp +++ /dev/null @@ -1,740 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hks_openssl_hmac_mt_test.h" - -#include - -#include "hks_api.h" -#include "hks_mem.h" -#include "hks_param.h" - -using namespace testing::ext; -namespace { -namespace { -const char HMAC_KEY[] = "This is a HMAC key"; -} // namespace -class HksHmacMtTest : public testing::Test {}; - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00100 - * @tc.name : HksHmacMtTest00100 - * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA1 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00100, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { - .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - - HksParam *outParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); - - HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; - (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); - - EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA1, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - HksFreeParamSet(¶mOutSet); - free(localKey.blob.data); - free(macMessage.data); - free(macForHuks.data); - free(key.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00200 - * @tc.name : HksHmacMtTest00200 - * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA224 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00200, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { - .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - - HksParam *outParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); - - HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; - (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); - - EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA224, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - HksFreeParamSet(¶mOutSet); - free(localKey.blob.data); - free(macMessage.data); - free(macForHuks.data); - free(key.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00300 - * @tc.name : HksHmacMtTest00300 - * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA256 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00300, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { - .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - - HksParam *outParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); - - HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; - (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); - - EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA256, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - HksFreeParamSet(¶mOutSet); - free(localKey.blob.data); - free(macMessage.data); - free(macForHuks.data); - free(key.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00400 - * @tc.name : HksHmacMtTest00400 - * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA384 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00400, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { - .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - - HksParam *outParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); - - HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; - (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); - - EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA384, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - HksFreeParamSet(¶mOutSet); - free(localKey.blob.data); - free(macMessage.data); - free(macForHuks.data); - free(key.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00500 - * @tc.name : HksHmacMtTest00500 - * @tc.desc : huks generates HMAC key, which can be successfully used for OpenSSL using HMAC-SHA512 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00500, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - struct HksParamSet *paramOutSet = NULL; - HksInitParamSet(¶mOutSet); - struct HksParam localKey = { - .tag = HKS_TAG_SYMMETRIC_KEY_DATA, .blob = {.size = HMAC_KEY_SIZE, .data = (uint8_t *)malloc(HMAC_KEY_SIZE)}}; - HksAddParams(paramOutSet, &localKey, 1); - - HksBuildParamSet(¶mOutSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramOutSet), HKS_SUCCESS); - - HksParam *outParam = NULL; - HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &outParam); - - HksBlob key = {.size = outParam->blob.size, .data = (uint8_t *)malloc(outParam->blob.size)}; - (void)memcpy_s(key.data, outParam->blob.size, outParam->blob.data, outParam->blob.size); - - EXPECT_EQ(HmacHmac(&key, HKS_DIGEST_SHA512, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&key, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - HksFreeParamSet(¶mOutSet); - free(localKey.blob.data); - free(macMessage.data); - free(macForHuks.data); - free(key.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00600 - * @tc.name : HksHmacMtTest00600 - * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00600, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); - - EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA1, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macMessage.data); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00700 - * @tc.name : HksHmacMtTest00700 - * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00700, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); - - EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA224, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macMessage.data); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00800 - * @tc.name : HksHmacMtTest00800 - * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00800, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); - - EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA256, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macMessage.data); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest00900 - * @tc.name : HksHmacMtTest00900 - * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest00900, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); - - EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA384, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macMessage.data); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest01000 - * @tc.name : HksHmacMtTest01000 - * @tc.desc : OpenSSL generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest01000, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macMessage = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HmacGenerateKey(HMAC_KEY_SIZE, &authId), HMAC_SUCCESS); - - EXPECT_EQ(HmacHmac(&authId, HKS_DIGEST_SHA512, &message, &macMessage), HMAC_SUCCESS); - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - EXPECT_EQ(macMessage.size, macForHuks.size); - EXPECT_EQ(HksMemCmp(macMessage.data, macForHuks.data, macForHuks.size), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macMessage.data); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest01100 - * @tc.name : HksHmacMtTest01100 - * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA1 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest01100, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest01200 - * @tc.name : HksHmacMtTest01200 - * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA224 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest01200, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest01300 - * @tc.name : HksHmacMtTest01300 - * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA256 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest01300, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest01400 - * @tc.name : HksHmacMtTest01400 - * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA384 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest01400, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macForHuks.data); -} - -/** - * @tc.number : HksHmacMtTest.HksHmacMtTest01500 - * @tc.name : HksHmacMtTest01500 - * @tc.desc : huks generates HMAC key, which can be successfully used for huks using HMAC-SHA512 hash operation - */ -HWTEST_F(HksHmacMtTest, HksHmacMtTest01500, TestSize.Level1) -{ - struct HksBlob authId = {strlen(HMAC_KEY), (uint8_t *)HMAC_KEY}; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - - struct HksParam tmpParams[] = { - {.tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT}, - {.tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC}, - {.tag = HKS_TAG_KEY_SIZE, .uint32Param = HMAC_KEY_SIZE}, - {.tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC}, - {.tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512}, - {.tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true}, - {.tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT}, - }; - - HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); - HksBuildParamSet(¶mInSet); - - const char *hexData = "0123456789abcdef"; - uint32_t dataLen = strlen(hexData); - HksBlob message = {.size = dataLen, .data = (uint8_t *)hexData}; - HksBlob macForHuks = {.size = HMAC_MESSAGE_SIZE, .data = (uint8_t *)malloc(HMAC_MESSAGE_SIZE)}; - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); - - EXPECT_EQ(HksMac(&authId, paramInSet, &message, &macForHuks), HKS_SUCCESS); - - HksFreeParamSet(¶mInSet); - free(macForHuks.data); -} -} // namespace \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_common_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_common_mt.cpp new file mode 100755 index 00000000..007aa6a4 --- /dev/null +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_common_mt.cpp @@ -0,0 +1,522 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hks_rsa_common_mt.h" +#include "openssl_rsa_helper.h" + +#include + +#include "hks_api.h" +#include "hks_mem.h" + +using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { +namespace { +const int SET_SIZE_4096 = 4096; +} + +void HksRsaCommonMt::GenerateKeyTestCase(const GenerateKeyCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), testCaseParams.generateKeyResult); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) }; + ASSERT_NE(cipherText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.encryptResult); + + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ( + DecryptRSA(&cipherText, &decryptedText, &privateKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.decryptResult); + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + + HksFree(decryptedText.data); + } + + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(paramSetOut); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::EncryptLocalTestCase(const EncryptLocalCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) }; + ASSERT_NE(cipherText.data, nullptr); + + EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult); + + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ( + DecryptRSA(&cipherText, &decryptedText, &privateKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.decryptResult); + + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + + HksFree(decryptedText.data); + } + HksFree(paramSetOut); + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::EncryptServiceTestCase(const EncryptServiceCaseParams &testCaseParams) +{ + struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(), + .data = (uint8_t *)&testCaseParams.alias[0] }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + ASSERT_NE(cipherText.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + + EVP_PKEY *pkey = GenerateRSAKey(testCaseParams.keySize); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, testCaseParams.keySize, &opensslRsaKeyInfo); + + EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), testCaseParams.encryptResult); + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + + EXPECT_EQ( + DecryptRSA( + &cipherText, &decryptedText, &opensslRsaKeyInfo, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.decryptResult); + + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + + HksFree(decryptedText.data); + } + + EVP_PKEY_free(pkey); + HksFree(cipherText.data); + HksFree(x509Key.data); + HksFree(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::DecryptLocalTestCase(const DecryptLocalCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) }; + ASSERT_NE(cipherText.data, nullptr); + + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.encryptResult); + + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), testCaseParams.decryptResult); + if (testCaseParams.decryptResult == HKS_SUCCESS) { + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + } + HksFree(decryptedText.data); + } + HksFree(paramSetOut); + HksFree(publicKey.data); + HksFree(privateKey.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::DecryptServiceTestCase(const DecryptServiceCaseParams &testCaseParams) +{ + struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(), + .data = (uint8_t *)&testCaseParams.alias[0] }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)HksMalloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + HksBlob plainText = { .size = (uint32_t)testCaseParams.hexData.length(), + .data = (uint8_t *)&testCaseParams.hexData[0] }; + HksParam *cipherLenBit = NULL; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); + uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; + HksBlob cipherText = { .size = inLength, .data = (uint8_t *)HksMalloc(inLength) }; + ASSERT_NE(cipherText.data, nullptr); + EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.encryptResult); + + if (testCaseParams.encryptResult == HKS_SUCCESS) { + HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(decryptedText.data, nullptr); + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), testCaseParams.decryptResult); + + if (testCaseParams.decryptResult == HKS_SUCCESS) { + EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + } + HksFree(decryptedText.data); + } + + HksFree(paramSetOut); + HksFree(publicKey.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::SignLocalTestCase(const SignLocalCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), testCaseParams.signResult); + if (testCaseParams.signResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.verifyResult); + HksFree(publicKey.data); + } + + HksFree(paramSetOut); + HksFree(privateKey.data); + HksFree(signData.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::SignServiceTestCase(const SignServiceCaseParams &testCaseParams) +{ + struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(), + .data = (uint8_t *)&testCaseParams.alias[0] }; + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), testCaseParams.signResult); + if (testCaseParams.signResult == HKS_SUCCESS) { + uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; + uint32_t opensslRsaKeyLen = SET_SIZE_4096; + struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; + EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); + + uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; + uint32_t rsaPublicKeyLen = SET_SIZE_4096; + struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; + EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); + + HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)HksMalloc(rsaPublicKeyInfo.size) }; + (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); + + EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.verifyResult); + HksFree(publicKey.data); + } + HksFree(paramSetOut); + HksFree(signData.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::VerifyLocalTestCase(const VerifyLocalCaseParams &testCaseParams) +{ + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + struct HksParamSet *paramSetOut = (struct HksParamSet *)HksMalloc(SET_SIZE_4096); + ASSERT_NE(paramSetOut, nullptr); + (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); + paramSetOut->paramSetSize = SET_SIZE_4096; + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); + + HksParam *priKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); + + HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)HksMalloc(priKeyExport->blob.size) }; + ASSERT_NE(privateKey.data, nullptr); + (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.signResult); + if (testCaseParams.signResult == HKS_SUCCESS) { + HksParam *pubKeyExport = NULL; + EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); + + HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)HksMalloc(pubKeyExport->blob.size) }; + ASSERT_NE(publicKey.data, nullptr); + (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); + EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), testCaseParams.verifyResult); + HksFree(publicKey.data); + } + HksFree(paramSetOut); + HksFree(privateKey.data); + HksFree(signData.data); + HksFreeParamSet(¶mInSet); +} + +void HksRsaCommonMt::VerifyServiceTestCase(const VerifyServiceCaseParams &testCaseParams) +{ + struct HksBlob authId = { .size = (uint32_t)testCaseParams.alias.length(), + .data = (uint8_t *)&testCaseParams.alias[0] }; + + struct HksParamSet *paramInSet = NULL; + HksInitParamSet(¶mInSet); + ASSERT_NE(paramInSet, nullptr); + + EXPECT_EQ(HksAddParams(paramInSet, testCaseParams.params.data(), testCaseParams.params.size()), HKS_SUCCESS); + + EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + + const char *hexData = "00112233445566778899aabbccddeeff"; + + HksBlob plainText = { .size = (uint32_t)strlen(hexData), .data = (uint8_t *)hexData }; + + HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(signData.data, nullptr); + + struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + ASSERT_NE(opensslRsaKeyInfo.data, nullptr); + + struct HksBlob x509Key = { .size = SET_SIZE_4096, .data = (uint8_t *)HksMalloc(SET_SIZE_4096) }; + + EVP_PKEY *pkey = GenerateRSAKey(testCaseParams.keySize); + ASSERT_NE(pkey, nullptr); + + OpensslGetx509PubKey(pkey, &x509Key); + + EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); + + SaveRsaKeyToHksBlob(pkey, testCaseParams.keySize, &opensslRsaKeyInfo); + EXPECT_EQ( + OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, testCaseParams.padding, testCaseParams.keyDigest), + testCaseParams.signResult); + if (testCaseParams.signResult == HKS_SUCCESS) { + EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), testCaseParams.verifyResult); + } + EVP_PKEY_free(pkey); + HksFree(signData.data); + HksFree(x509Key.data); + HksFree(opensslRsaKeyInfo.data); + HksFreeParamSet(¶mInSet); +} +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp index a2e27e9d..f60a6040 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_nopadding_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,2396 +25,1153 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for NoPadding"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -const char HEXDATA_4096[] = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123456789012345678901"; -} // namespace -class HksRsaEcbNopaddingMt : public testing::Test {}; - -static const struct HksParam RSA_00100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_00100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest00100 - * @tc.name : HksRsaMtTest00100 - * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00100_PARAMS, sizeof(RSA_00100_PARAMS) / sizeof(RSA_00100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(publicKey.data); - free(privateKey.data); - free(paramSetOut); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_00200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_00200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest00200 - * @tc.name : HksRsaMtTest00200 - * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00200_PARAMS, sizeof(RSA_00200_PARAMS) / sizeof(RSA_00200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = - "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_00300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_00300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest00300 - * @tc.name : HksRsaMtTest00300 - * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00300_PARAMS, sizeof(RSA_00300_PARAMS) / sizeof(RSA_00300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "234567890123456789012345678901234567"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_00400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_00400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest00400 - * @tc.name : HksRsaMtTest00400 - * @tc.desc : Test huks generate key (2048_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00400, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00400_PARAMS, sizeof(RSA_00400_PARAMS) / sizeof(RSA_00400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" - "456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_00500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_00500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest00500 - * @tc.name : HksRsaMtTest00500 - * @tc.desc : Test huks generate key (3072_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00500, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00500_PARAMS, sizeof(RSA_00500_PARAMS) / sizeof(RSA_00500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_00600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_00600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest00600 - * @tc.name : HksRsaMtTest00600 - * @tc.desc : Test huks generate key (4096_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00600, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00600_PARAMS, sizeof(RSA_00600_PARAMS) / sizeof(RSA_00600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123456789012345678901"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_00700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const EncryptLocalCaseParams HKS_RSA_MT_00700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif }; -/** - * @tc.number : HksRsaMtTest00700 - * @tc.name : HksRsaMtTest00700 - * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00700, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00700_PARAMS, sizeof(RSA_00700_PARAMS) / sizeof(RSA_00700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - +const EncryptServiceCaseParams HKS_RSA_MT_00800_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_00800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; -/** - * @tc.number : HksRsaMtTest00800 - * @tc.name : HksRsaMtTest00800 - * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00800_PARAMS, sizeof(RSA_00800_PARAMS) / sizeof(RSA_00800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - +const EncryptLocalCaseParams HKS_RSA_MT_00900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_00900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; -/** - * @tc.number : HksRsaMtTest00900 - * @tc.name : HksRsaMtTest00900 - * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest00900, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_00900_PARAMS, sizeof(RSA_00900_PARAMS) / sizeof(RSA_00900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = - "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - +const EncryptServiceCaseParams HKS_RSA_MT_01000_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_01000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; -/** - * @tc.number : HksRsaMtTest01000 - * @tc.name : HksRsaMtTest01000 - * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01000_PARAMS, sizeof(RSA_01000_PARAMS) / sizeof(RSA_01000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = - "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - +const EncryptLocalCaseParams HKS_RSA_MT_01100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_01100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; -/** - * @tc.number : HksRsaMtTest01100 - * @tc.name : HksRsaMtTest01100 - * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01100_PARAMS, sizeof(RSA_01100_PARAMS) / sizeof(RSA_01100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "234567890123456789012345678901234567"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - +const EncryptServiceCaseParams HKS_RSA_MT_01200_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_01200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; -/** - * @tc.number : HksRsaMtTest01200 - * @tc.name : HksRsaMtTest01200 - * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01200_PARAMS, sizeof(RSA_01200_PARAMS) / sizeof(RSA_01200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "234567890123456789012345678901234567"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - +const EncryptLocalCaseParams HKS_RSA_MT_01300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_01300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; -/** - * @tc.number : HksRsaMtTest01300 - * @tc.name : HksRsaMtTest01300 - * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01300_PARAMS, sizeof(RSA_01300_PARAMS) / sizeof(RSA_01300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" - "456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - +const EncryptServiceCaseParams HKS_RSA_MT_01400_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_01400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; -/** - * @tc.number : HksRsaMtTest01400 - * @tc.name : HksRsaMtTest01400 - * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01400_PARAMS, sizeof(RSA_01400_PARAMS) / sizeof(RSA_01400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" - "456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - +const EncryptLocalCaseParams HKS_RSA_MT_01500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), RSA_SUCCESS); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_ERROR_NOT_SUPPORTED, #endif - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_01500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, }; -/** - * @tc.number : HksRsaMtTest01500 - * @tc.name : HksRsaMtTest01500 - * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/NoPadding/TEMP) - */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01500, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01500_PARAMS, sizeof(RSA_01500_PARAMS) / sizeof(RSA_01500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const EncryptServiceCaseParams HKS_RSA_MT_01600_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_01700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const EncryptServiceCaseParams HKS_RSA_MT_01800_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const DecryptLocalCaseParams HKS_RSA_MT_01900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_02000_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const DecryptLocalCaseParams HKS_RSA_MT_02100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123"; +const DecryptServiceCaseParams HKS_RSA_MT_02200_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const DecryptLocalCaseParams HKS_RSA_MT_02300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const DecryptServiceCaseParams HKS_RSA_MT_02400_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); +const DecryptLocalCaseParams HKS_RSA_MT_02500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; +const DecryptServiceCaseParams HKS_RSA_MT_02600_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "67890123456789012345678901234567890123456789012345", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, #if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_02700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +const DecryptServiceCaseParams HKS_RSA_MT_02800_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "901234567890123456789012345678901234567890123456789012345678901234567890123", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, #endif #if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, #endif +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} +const DecryptLocalCaseParams HKS_RSA_MT_02900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif +}; -static const struct HksParam RSA_01600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const DecryptServiceCaseParams HKS_RSA_MT_03000_PARAMS = { + .alias = "This is a test auth id for NoPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012" + "3456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345" + "6789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + "9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" + "2345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901", + .padding = RSA_NO_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_OPENSSL_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +#endif +#if defined(_USE_MBEDTLS_) + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_ERROR_NOT_SUPPORTED, +#endif }; +} // namespace + +class HksRsaEcbNopaddingMt : public HksRsaCommonMt, public testing::Test {}; /** - * @tc.number : HksRsaMtTest01600 - * @tc.name : HksRsaMtTest01600 - * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + * @tc.number : HksRsaEcbNopaddingMt00100 + * @tc.name : HksRsaEcbNopaddingMt00100 + * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/NoPadding/TEMP) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01600, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00100, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01600_PARAMS, sizeof(RSA_01600_PARAMS) / sizeof(RSA_01600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); + GenerateKeyTestCase(HKS_RSA_MT_00100_PARAMS); +} - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123"; +/** + * @tc.number : HksRsaEcbNopaddingMt00200 + * @tc.name : HksRsaEcbNopaddingMt00200 + * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00200_PARAMS); +} - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +/** + * @tc.number : HksRsaEcbNopaddingMt00300 + * @tc.name : HksRsaEcbNopaddingMt00300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00300_PARAMS); +} - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); +/** + * @tc.number : HksRsaEcbNopaddingMt00400 + * @tc.name : HksRsaEcbNopaddingMt00400 + * @tc.desc : Test huks generate key (2048_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00400, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00400_PARAMS); +} - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); +/** + * @tc.number : HksRsaEcbNopaddingMt00500 + * @tc.name : HksRsaEcbNopaddingMt00500 + * @tc.desc : Test huks generate key (3072_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00500, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00500_PARAMS); +} - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); +/** + * @tc.number : HksRsaEcbNopaddingMt00600 + * @tc.name : HksRsaEcbNopaddingMt00600 + * @tc.desc : Test huks generate key (4096_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00600, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_00600_PARAMS); +} - struct HksBlob x509Key = { 0, NULL }; +/** + * @tc.number : HksRsaEcbNopaddingMt00700 + * @tc.name : HksRsaEcbNopaddingMt00700 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00700, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_00700_PARAMS); +} - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); +/** + * @tc.number : HksRsaEcbNopaddingMt00800 + * @tc.name : HksRsaEcbNopaddingMt00800 + * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00800, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_00800_PARAMS); +} - OpensslGetx509PubKey(pkey, &x509Key); +/** + * @tc.number : HksRsaEcbNopaddingMt00900 + * @tc.name : HksRsaEcbNopaddingMt00900 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt00900, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_00900_PARAMS); +} - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); +/** + * @tc.number : HksRsaEcbNopaddingMt01000 + * @tc.name : HksRsaEcbNopaddingMt01000 + * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01000, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01000_PARAMS); +} - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); +/** + * @tc.number : HksRsaEcbNopaddingMt01100 + * @tc.name : HksRsaEcbNopaddingMt01100 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01100, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_01100_PARAMS); +} -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); +/** + * @tc.number : HksRsaEcbNopaddingMt01200 + * @tc.name : HksRsaEcbNopaddingMt01200 + * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01200, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01200_PARAMS); +} - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); +/** + * @tc.number : HksRsaEcbNopaddingMt01300 + * @tc.name : HksRsaEcbNopaddingMt01300 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01300, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_01300_PARAMS); +} - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); -#endif +/** + * @tc.number : HksRsaEcbNopaddingMt01400 + * @tc.name : HksRsaEcbNopaddingMt01400 + * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01400, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01400_PARAMS); +} - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaEcbNopaddingMt01500 + * @tc.name : HksRsaEcbNopaddingMt01500 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/NoPadding/TEMP) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01500, TestSize.Level1) +{ + EncryptLocalTestCase(HKS_RSA_MT_01500_PARAMS); } -static const struct HksParam RSA_01700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaEcbNopaddingMt01600 + * @tc.name : HksRsaEcbNopaddingMt01600 + * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) + */ +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01600, TestSize.Level1) +{ + EncryptServiceTestCase(HKS_RSA_MT_01600_PARAMS); +} /** - * @tc.number : HksRsaMtTest01700 - * @tc.name : HksRsaMtTest01700 + * @tc.number : HksRsaEcbNopaddingMt01700 + * @tc.name : HksRsaEcbNopaddingMt01700 * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/NoPadding/TEMP) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01700, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01700_PARAMS, sizeof(RSA_01700_PARAMS) / sizeof(RSA_01700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - HksBlob plainText = { .size = strlen(HEXDATA_4096), .data = (uint8_t *)HEXDATA_4096 }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_01700_PARAMS); } -static const struct HksParam RSA_01800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest01800 - * @tc.name : HksRsaMtTest01800 + * @tc.number : HksRsaEcbNopaddingMt01800 + * @tc.name : HksRsaEcbNopaddingMt01800 * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01800, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01800_PARAMS, sizeof(RSA_01800_PARAMS) / sizeof(RSA_01800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123456789012345678901"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_NOT_SUPPORTED); -#endif - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_01800_PARAMS); } -static const struct HksParam RSA_01900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest01900 - * @tc.name : HksRsaMtTest01900 + * @tc.number : HksRsaEcbNopaddingMt01900 + * @tc.name : HksRsaEcbNopaddingMt01900 * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/NoPadding/TEMP) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest01900, TestSize.Level1) - +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt01900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_01900_PARAMS, sizeof(RSA_01900_PARAMS) / sizeof(RSA_01900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_01900_PARAMS); } -static const struct HksParam RSA_02000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02000 - * @tc.name : HksRsaMtTest02000 + * @tc.number : HksRsaEcbNopaddingMt02000 + * @tc.name : HksRsaEcbNopaddingMt02000 * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02000, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02000_PARAMS, sizeof(RSA_02000_PARAMS) / sizeof(RSA_02000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "0123456789012345678901234567890123456789012345678901234567890123"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_02000_PARAMS); } -static const struct HksParam RSA_02100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02100 - * @tc.name : HksRsaMtTest02100 + * @tc.number : HksRsaEcbNopaddingMt02100 + * @tc.name : HksRsaEcbNopaddingMt02100 * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/NoPadding/TEMP) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02100, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02100_PARAMS, sizeof(RSA_02100_PARAMS) / sizeof(RSA_02100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = - "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_02100_PARAMS); } -static const struct HksParam RSA_02200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02200 - * @tc.name : HksRsaMtTest02200 + * @tc.number : HksRsaEcbNopaddingMt02200 + * @tc.name : HksRsaEcbNopaddingMt02200 * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02200, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02200_PARAMS, sizeof(RSA_02200_PARAMS) / sizeof(RSA_02200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = - "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_02200_PARAMS); } -static const struct HksParam RSA_02300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02300 - * @tc.name : HksRsaMtTest02300 + * @tc.number : HksRsaEcbNopaddingMt02300 + * @tc.name : HksRsaEcbNopaddingMt02300 * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/NoPadding/TEMP) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02300, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02300_PARAMS, sizeof(RSA_02300_PARAMS) / sizeof(RSA_02300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "234567890123456789012345678901234567"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_02300_PARAMS); } -static const struct HksParam RSA_02400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02400 - * @tc.name : HksRsaMtTest02400 + * @tc.number : HksRsaEcbNopaddingMt02400 + * @tc.name : HksRsaEcbNopaddingMt02400 * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02400, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02400_PARAMS, sizeof(RSA_02400_PARAMS) / sizeof(RSA_02400_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "234567890123456789012345678901234567"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_02400_PARAMS); } -static const struct HksParam RSA_02500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02500 - * @tc.name : HksRsaMtTest02500 + * @tc.number : HksRsaEcbNopaddingMt02500 + * @tc.name : HksRsaEcbNopaddingMt02500 * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/NoPadding/TEMP) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02500, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02500_PARAMS, sizeof(RSA_02500_PARAMS) / sizeof(RSA_02500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" - "456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_02500_PARAMS); } -static const struct HksParam RSA_02600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02600 - * @tc.name : HksRsaMtTest02600 + * @tc.number : HksRsaEcbNopaddingMt02600 + * @tc.name : HksRsaEcbNopaddingMt02600 * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02600, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02600_PARAMS, sizeof(RSA_02600_PARAMS) / sizeof(RSA_02600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" - "23456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123" - "456789012345678901234567890123456789012345678901234567890123456789012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_02600_PARAMS); } -static const struct HksParam RSA_02700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02700 - * @tc.name : HksRsaMtTest02700 + * @tc.number : HksRsaEcbNopaddingMt02700 + * @tc.name : HksRsaEcbNopaddingMt02700 * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/NoPadding/TEMP) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02700, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02700_PARAMS, sizeof(RSA_02700_PARAMS) / sizeof(RSA_02700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_02700_PARAMS); } -static const struct HksParam RSA_02800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02800 - * @tc.name : HksRsaMtTest02800 + * @tc.number : HksRsaEcbNopaddingMt02800 + * @tc.name : HksRsaEcbNopaddingMt02800 * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02800, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02800_PARAMS, sizeof(RSA_02800_PARAMS) / sizeof(RSA_02800_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - "012345678901234567890123456789012345678901234567890123"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_02800_PARAMS); } -static const struct HksParam RSA_02900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest02900 - * @tc.name : HksRsaMtTest02900 + * @tc.number : HksRsaEcbNopaddingMt02900 + * @tc.name : HksRsaEcbNopaddingMt02900 * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/NoPadding/TEMP) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest02900, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt02900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_02900_PARAMS, sizeof(RSA_02900_PARAMS) / sizeof(RSA_02900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - HksBlob plainText = { .size = strlen(HEXDATA_4096), .data = (uint8_t *)HEXDATA_4096 }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_02900_PARAMS); } -static const struct HksParam RSA_03000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest03000 - * @tc.name : HksRsaMtTest03000 + * @tc.number : HksRsaEcbNopaddingMt03000 + * @tc.name : HksRsaEcbNopaddingMt03000 * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/NoPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbNopaddingMt, HksRsaMtTest03000, TestSize.Level1) +HWTEST_F(HksRsaEcbNopaddingMt, HksRsaEcbNopaddingMt03000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_03000_PARAMS, sizeof(RSA_03000_PARAMS) / sizeof(RSA_03000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - HksBlob plainText = { .size = strlen(HEXDATA_4096), .data = (uint8_t *)HEXDATA_4096 }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_NO_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - -#if defined(_USE_OPENSSL_) - - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); -#endif -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_ERROR_NOT_SUPPORTED); -#endif - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_03000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp index be59a5ea..a2d841fb 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_padding_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,2188 +25,969 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for OAEPPadding"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace -class HksRsaEcbOaepPaddingMt : public testing::Test {}; - -static const struct HksParam RSA_03100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_03100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest03100 - * @tc.name : HksRsaMtTest03100 - * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_03100_PARAMS, sizeof(RSA_03100_PARAMS) / sizeof(RSA_03100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(publicKey.data); - free(privateKey.data); - free(paramSetOut); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} - -static const struct HksParam RSA_03200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_03200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest03200 - * @tc.name : HksRsaMtTest03200 - * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const GenerateKeyCaseParams HKS_RSA_MT_03300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const GenerateKeyCaseParams HKS_RSA_MT_03400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_03200_PARAMS, sizeof(RSA_03200_PARAMS) / sizeof(RSA_03200_PARAMS[0])), - HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_03500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_03600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_03700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const EncryptServiceCaseParams HKS_RSA_MT_03800_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const EncryptLocalCaseParams HKS_RSA_MT_03900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const EncryptServiceCaseParams HKS_RSA_MT_04000_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const EncryptLocalCaseParams HKS_RSA_MT_04100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_04200_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); +const EncryptLocalCaseParams HKS_RSA_MT_04300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); +const EncryptServiceCaseParams HKS_RSA_MT_04400_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +const EncryptLocalCaseParams HKS_RSA_MT_04500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} +const EncryptServiceCaseParams HKS_RSA_MT_04600_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +const EncryptLocalCaseParams HKS_RSA_MT_04700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_03300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const EncryptServiceCaseParams HKS_RSA_MT_04800_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest03300 - * @tc.name : HksRsaMtTest03300 - * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const DecryptLocalCaseParams HKS_RSA_MT_04900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const DecryptServiceCaseParams HKS_RSA_MT_05000_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_03300_PARAMS, sizeof(RSA_03300_PARAMS) / sizeof(RSA_03300_PARAMS[0])), - HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_05100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_05200_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_05300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_05400_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const DecryptLocalCaseParams HKS_RSA_MT_05500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_05600_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const DecryptLocalCaseParams HKS_RSA_MT_05700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const DecryptServiceCaseParams HKS_RSA_MT_05800_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const DecryptLocalCaseParams HKS_RSA_MT_05900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const DecryptServiceCaseParams HKS_RSA_MT_06000_PARAMS = { + .alias = "This is a test auth id for OAEPPadding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); +class HksRsaEcbOaepPaddingMt : public HksRsaCommonMt, public testing::Test {}; - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); +/** + * @tc.number : HksRsaEcbOaepPaddingMt03100 + * @tc.name : HksRsaEcbOaepPaddingMt03100 + * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03100_PARAMS); +} - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +/** + * @tc.number : HksRsaEcbOaepPaddingMt03200 + * @tc.name : HksRsaEcbOaepPaddingMt03200 + * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03200_PARAMS); +} - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaEcbOaepPaddingMt03300 + * @tc.name : HksRsaEcbOaepPaddingMt03300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_03300_PARAMS); } -static const struct HksParam RSA_03400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; /** - * @tc.number : HksRsaMtTest03400 - * @tc.name : HksRsaMtTest03400 + * @tc.number : HksRsaEcbOaepPaddingMt03400 + * @tc.name : HksRsaEcbOaepPaddingMt03400 * @tc.desc : Test huks generate key (2048_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03400, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_03400_PARAMS, sizeof(RSA_03400_PARAMS) / sizeof(RSA_03400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_03400_PARAMS); } -static const struct HksParam RSA_03500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest03500 - * @tc.name : HksRsaMtTest03500 + * @tc.number : HksRsaEcbOaepPaddingMt03500 + * @tc.name : HksRsaEcbOaepPaddingMt03500 * @tc.desc : Test huks generate key (3072_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_03500_PARAMS, sizeof(RSA_03500_PARAMS) / sizeof(RSA_03500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_03500_PARAMS); } -static const struct HksParam RSA_03600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest03600 - * @tc.name : HksRsaMtTest03600 + * @tc.number : HksRsaEcbOaepPaddingMt03600 + * @tc.name : HksRsaEcbOaepPaddingMt03600 * @tc.desc : Test huks generate key (4096_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03600, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_03600_PARAMS, sizeof(RSA_03600_PARAMS) / sizeof(RSA_03600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_03600_PARAMS); } -static const struct HksParam RSA_03700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest03700 - * @tc.name : HksRsaMtTest03700 + * @tc.number : HksRsaEcbOaepPaddingMt03700 + * @tc.name : HksRsaEcbOaepPaddingMt03700 * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_03700_PARAMS, sizeof(RSA_03700_PARAMS) / sizeof(RSA_03700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_03700_PARAMS); } -static const struct HksParam RSA_03800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest03800 - * @tc.name : HksRsaMtTest03800 + * @tc.number : HksRsaEcbOaepPaddingMt03800 + * @tc.name : HksRsaEcbOaepPaddingMt03800 * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_03800_PARAMS, sizeof(RSA_03800_PARAMS) / sizeof(RSA_03800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_03800_PARAMS); } -static const struct HksParam RSA_03900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest03900 - * @tc.name : HksRsaMtTest03900 + * @tc.number : HksRsaEcbOaepPaddingMt03900 + * @tc.name : HksRsaEcbOaepPaddingMt03900 * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest03900, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt03900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_03900_PARAMS, sizeof(RSA_03900_PARAMS) / sizeof(RSA_03900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_03900_PARAMS); } -static const struct HksParam RSA_04000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04000 - * @tc.name : HksRsaMtTest04000 + * @tc.number : HksRsaEcbOaepPaddingMt04000 + * @tc.name : HksRsaEcbOaepPaddingMt04000 * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04000_PARAMS, sizeof(RSA_04000_PARAMS) / sizeof(RSA_04000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_04000_PARAMS); } -static const struct HksParam RSA_04100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04100 - * @tc.name : HksRsaMtTest04100 + * @tc.number : HksRsaEcbOaepPaddingMt04100 + * @tc.name : HksRsaEcbOaepPaddingMt04100 * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04100, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04100_PARAMS, sizeof(RSA_04100_PARAMS) / sizeof(RSA_04100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_04100_PARAMS); } -static const struct HksParam RSA_04200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04200 - * @tc.name : HksRsaMtTest04200 + * @tc.number : HksRsaEcbOaepPaddingMt04200 + * @tc.name : HksRsaEcbOaepPaddingMt04200 * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04200, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04200_PARAMS, sizeof(RSA_04200_PARAMS) / sizeof(RSA_04200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_04200_PARAMS); } -static const struct HksParam RSA_04300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04300 - * @tc.name : HksRsaMtTest04300 + * @tc.number : HksRsaEcbOaepPaddingMt04300 + * @tc.name : HksRsaEcbOaepPaddingMt04300 * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04300, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04300_PARAMS, sizeof(RSA_04300_PARAMS) / sizeof(RSA_04300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_04300_PARAMS); } -static const struct HksParam RSA_04400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04400 - * @tc.name : HksRsaMtTest04400 + * @tc.number : HksRsaEcbOaepPaddingMt04400 + * @tc.name : HksRsaEcbOaepPaddingMt04400 * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04400_PARAMS, sizeof(RSA_04400_PARAMS) / sizeof(RSA_04400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_04400_PARAMS); } -static const struct HksParam RSA_04500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04500 - * @tc.name : HksRsaMtTest04500 + * @tc.number : HksRsaEcbOaepPaddingMt04500 + * @tc.name : HksRsaEcbOaepPaddingMt04500 * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04500_PARAMS, sizeof(RSA_04500_PARAMS) / sizeof(RSA_04500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_04500_PARAMS); } -static const struct HksParam RSA_04600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04600 - * @tc.name : HksRsaMtTest04600 + * @tc.number : HksRsaEcbOaepPaddingMt04600 + * @tc.name : HksRsaEcbOaepPaddingMt04600 * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04600_PARAMS, sizeof(RSA_04600_PARAMS) / sizeof(RSA_04600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_04600_PARAMS); } -static const struct HksParam RSA_04700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04700 - * @tc.name : HksRsaMtTest04700 + * @tc.number : HksRsaEcbOaepPaddingMt04700 + * @tc.name : HksRsaEcbOaepPaddingMt04700 * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04700_PARAMS, sizeof(RSA_04700_PARAMS) / sizeof(RSA_04700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_04700_PARAMS); } -static const struct HksParam RSA_04800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04800 - * @tc.name : HksRsaMtTest04800 + * @tc.number : HksRsaEcbOaepPaddingMt04800 + * @tc.name : HksRsaEcbOaepPaddingMt04800 * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04800_PARAMS, sizeof(RSA_04800_PARAMS) / sizeof(RSA_04800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_04800_PARAMS); } -static const struct HksParam RSA_04900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest04900 - * @tc.name : HksRsaMtTest04900 + * @tc.number : HksRsaEcbOaepPaddingMt04900 + * @tc.name : HksRsaEcbOaepPaddingMt04900 * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest04900, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt04900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_04900_PARAMS, sizeof(RSA_04900_PARAMS) / sizeof(RSA_04900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_04900_PARAMS); } -static const struct HksParam RSA_05000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05000 - * @tc.name : HksRsaMtTest05000 + * @tc.number : HksRsaEcbOaepPaddingMt05000 + * @tc.name : HksRsaEcbOaepPaddingMt05000 * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05000_PARAMS, sizeof(RSA_05000_PARAMS) / sizeof(RSA_05000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_05000_PARAMS); } -static const struct HksParam RSA_05100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05100 - * @tc.name : HksRsaMtTest05100 + * @tc.number : HksRsaEcbOaepPaddingMt05100 + * @tc.name : HksRsaEcbOaepPaddingMt05100 * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05100, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05100_PARAMS, sizeof(RSA_05100_PARAMS) / sizeof(RSA_05100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_05100_PARAMS); } -static const struct HksParam RSA_05200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05200 - * @tc.name : HksRsaMtTest05200 + * @tc.number : HksRsaEcbOaepPaddingMt05200 + * @tc.name : HksRsaEcbOaepPaddingMt05200 * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05200, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05200_PARAMS, sizeof(RSA_05200_PARAMS) / sizeof(RSA_05200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_05200_PARAMS); } -static const struct HksParam RSA_05300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05300 - * @tc.name : HksRsaMtTest05300 + * @tc.number : HksRsaEcbOaepPaddingMt05300 + * @tc.name : HksRsaEcbOaepPaddingMt05300 * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05300, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05300_PARAMS, sizeof(RSA_05300_PARAMS) / sizeof(RSA_05300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_05300_PARAMS); } -static const struct HksParam RSA_05400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05400 - * @tc.name : HksRsaMtTest05400 + * @tc.number : HksRsaEcbOaepPaddingMt05400 + * @tc.name : HksRsaEcbOaepPaddingMt05400 * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05400_PARAMS, sizeof(RSA_05400_PARAMS) / sizeof(RSA_05400_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_05400_PARAMS); } -static const struct HksParam RSA_05500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05500 - * @tc.name : HksRsaMtTest05500 + * @tc.number : HksRsaEcbOaepPaddingMt05500 + * @tc.name : HksRsaEcbOaepPaddingMt05500 * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05500_PARAMS, sizeof(RSA_05500_PARAMS) / sizeof(RSA_05500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_05500_PARAMS); } -static const struct HksParam RSA_05600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05600 - * @tc.name : HksRsaMtTest05600 + * @tc.number : HksRsaEcbOaepPaddingMt05600 + * @tc.name : HksRsaEcbOaepPaddingMt05600 * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05600_PARAMS, sizeof(RSA_05600_PARAMS) / sizeof(RSA_05600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_05600_PARAMS); } -static const struct HksParam RSA_05700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05700 - * @tc.name : HksRsaMtTest05700 + * @tc.number : HksRsaEcbOaepPaddingMt05700 + * @tc.name : HksRsaEcbOaepPaddingMt05700 * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05700_PARAMS, sizeof(RSA_05700_PARAMS) / sizeof(RSA_05700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_05700_PARAMS); } -static const struct HksParam RSA_05800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05800 - * @tc.name : HksRsaMtTest05800 + * @tc.number : HksRsaEcbOaepPaddingMt05800 + * @tc.name : HksRsaEcbOaepPaddingMt05800 * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05800_PARAMS, sizeof(RSA_05800_PARAMS) / sizeof(RSA_05800_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_05800_PARAMS); } -static const struct HksParam RSA_05900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest05900 - * @tc.name : HksRsaMtTest05900 + * @tc.number : HksRsaEcbOaepPaddingMt05900 + * @tc.name : HksRsaEcbOaepPaddingMt05900 * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPPadding/TEMP) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest05900, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt05900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_05900_PARAMS, sizeof(RSA_05900_PARAMS) / sizeof(RSA_05900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_05900_PARAMS); } -static const struct HksParam RSA_06000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest06000 - * @tc.name : HksRsaMtTest06000 + * @tc.number : HksRsaEcbOaepPaddingMt06000 + * @tc.name : HksRsaEcbOaepPaddingMt06000 * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPPadding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaMtTest06000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepPaddingMt, HksRsaEcbOaepPaddingMt06000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_06000_PARAMS, sizeof(RSA_06000_PARAMS) / sizeof(RSA_06000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_06000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp index 00d510b4..a0d94196 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha1_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,2188 +25,971 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for OAEPWithSHA-1"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace -class HksRsaEcbOaepSha1Mt : public testing::Test {}; - -static const struct HksParam RSA_06100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_06100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest06100 - * @tc.name : HksRsaMtTest06100 - * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_06100_PARAMS, sizeof(RSA_06100_PARAMS) / sizeof(RSA_06100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(publicKey.data); - free(privateKey.data); - free(paramSetOut); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} +const GenerateKeyCaseParams HKS_RSA_MT_06200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_06200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_06300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest06200 - * @tc.name : HksRsaMtTest06200 - * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const GenerateKeyCaseParams HKS_RSA_MT_06400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_06200_PARAMS, sizeof(RSA_06200_PARAMS) / sizeof(RSA_06200_PARAMS[0])), - HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_06500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_06600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_06700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const EncryptServiceCaseParams HKS_RSA_MT_06800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const EncryptLocalCaseParams HKS_RSA_MT_06900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const EncryptServiceCaseParams HKS_RSA_MT_07000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const EncryptLocalCaseParams HKS_RSA_MT_07100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_07200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); +const EncryptLocalCaseParams HKS_RSA_MT_07300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); +const EncryptServiceCaseParams HKS_RSA_MT_07400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +const EncryptLocalCaseParams HKS_RSA_MT_07500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} +const EncryptServiceCaseParams HKS_RSA_MT_07600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_06300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const EncryptLocalCaseParams HKS_RSA_MT_07700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest06300 - * @tc.name : HksRsaMtTest06300 - * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_07800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const DecryptLocalCaseParams HKS_RSA_MT_07900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_06300_PARAMS, sizeof(RSA_06300_PARAMS) / sizeof(RSA_06300_PARAMS[0])), - HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_08000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_08100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_08200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_08300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_08400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_08500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_08600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const DecryptLocalCaseParams HKS_RSA_MT_08700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const DecryptServiceCaseParams HKS_RSA_MT_08800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const DecryptLocalCaseParams HKS_RSA_MT_08900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); +const DecryptServiceCaseParams HKS_RSA_MT_09000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); +class HksRsaEcbOaepSha1Mt : public HksRsaCommonMt, public testing::Test {}; - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +/** + * @tc.number : HksRsaEcbOaepSha1Mt06100 + * @tc.name : HksRsaEcbOaepSha1Mt06100 + * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06100_PARAMS); +} - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaEcbOaepSha1Mt06200 + * @tc.name : HksRsaEcbOaepSha1Mt06200 + * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06200_PARAMS); } -static const struct HksParam RSA_06400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaEcbOaepSha1Mt06300 + * @tc.name : HksRsaEcbOaepSha1Mt06300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_06300_PARAMS); +} /** - * @tc.number : HksRsaMtTest06400 - * @tc.name : HksRsaMtTest06400 + * @tc.number : HksRsaEcbOaepSha1Mt06400 + * @tc.name : HksRsaEcbOaepSha1Mt06400 * @tc.desc : Test huks generate key (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06400, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_06400_PARAMS, sizeof(RSA_06400_PARAMS) / sizeof(RSA_06400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_06400_PARAMS); } -static const struct HksParam RSA_06500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest06500 - * @tc.name : HksRsaMtTest06500 + * @tc.number : HksRsaEcbOaepSha1Mt06500 + * @tc.name : HksRsaEcbOaepSha1Mt06500 * @tc.desc : Test huks generate key (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_06500_PARAMS, sizeof(RSA_06500_PARAMS) / sizeof(RSA_06500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_06500_PARAMS); } -static const struct HksParam RSA_06600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest06600 - * @tc.name : HksRsaMtTest06600 + * @tc.number : HksRsaEcbOaepSha1Mt06600 + * @tc.name : HksRsaEcbOaepSha1Mt06600 * @tc.desc : Test huks generate key (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06600, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_06600_PARAMS, sizeof(RSA_06600_PARAMS) / sizeof(RSA_06600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_06600_PARAMS); } -static const struct HksParam RSA_06700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest06700 - * @tc.name : HksRsaMtTest06700 + * @tc.number : HksRsaEcbOaepSha1Mt06700 + * @tc.name : HksRsaEcbOaepSha1Mt06700 * @tc.desc : Test huks Encrypt (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_06700_PARAMS, sizeof(RSA_06700_PARAMS) / sizeof(RSA_06700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_06700_PARAMS); } -static const struct HksParam RSA_06800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest06800 - * @tc.name : HksRsaMtTest06800 + * @tc.number : HksRsaEcbOaepSha1Mt06800 + * @tc.name : HksRsaEcbOaepSha1Mt06800 * @tc.desc : Test huks Encrypt (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_06800_PARAMS, sizeof(RSA_06800_PARAMS) / sizeof(RSA_06800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_06800_PARAMS); } -static const struct HksParam RSA_06900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest06900 - * @tc.name : HksRsaMtTest06900 + * @tc.number : HksRsaEcbOaepSha1Mt06900 + * @tc.name : HksRsaEcbOaepSha1Mt06900 * @tc.desc : Test huks Encrypt (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest06900, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt06900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_06900_PARAMS, sizeof(RSA_06900_PARAMS) / sizeof(RSA_06900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_06900_PARAMS); } -static const struct HksParam RSA_07000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07000 - * @tc.name : HksRsaMtTest07000 + * @tc.number : HksRsaEcbOaepSha1Mt07000 + * @tc.name : HksRsaEcbOaepSha1Mt07000 * @tc.desc : Test huks Encrypt (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07000_PARAMS, sizeof(RSA_07000_PARAMS) / sizeof(RSA_07000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_07000_PARAMS); } -static const struct HksParam RSA_07100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07100 - * @tc.name : HksRsaMtTest07100 + * @tc.number : HksRsaEcbOaepSha1Mt07100 + * @tc.name : HksRsaEcbOaepSha1Mt07100 * @tc.desc : Test huks Encrypt (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07100, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07100_PARAMS, sizeof(RSA_07100_PARAMS) / sizeof(RSA_07100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_07100_PARAMS); } -static const struct HksParam RSA_07200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07200 - * @tc.name : HksRsaMtTest07200 + * @tc.number : HksRsaEcbOaepSha1Mt07200 + * @tc.name : HksRsaEcbOaepSha1Mt07200 * @tc.desc : Test huks Encrypt (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07200, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07200_PARAMS, sizeof(RSA_07200_PARAMS) / sizeof(RSA_07200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_07200_PARAMS); } -static const struct HksParam RSA_07300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07300 - * @tc.name : HksRsaMtTest07300 + * @tc.number : HksRsaEcbOaepSha1Mt07300 + * @tc.name : HksRsaEcbOaepSha1Mt07300 * @tc.desc : Test huks Encrypt (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07300, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07300_PARAMS, sizeof(RSA_07300_PARAMS) / sizeof(RSA_07300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_07300_PARAMS); } -static const struct HksParam RSA_07400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07400 - * @tc.name : HksRsaMtTest07400 + * @tc.number : HksRsaEcbOaepSha1Mt07400 + * @tc.name : HksRsaEcbOaepSha1Mt07400 * @tc.desc : Test huks Encrypt (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07400_PARAMS, sizeof(RSA_07400_PARAMS) / sizeof(RSA_07400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_07400_PARAMS); } -static const struct HksParam RSA_07500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07500 - * @tc.name : HksRsaMtTest07500 + * @tc.number : HksRsaEcbOaepSha1Mt07500 + * @tc.name : HksRsaEcbOaepSha1Mt07500 * @tc.desc : Test huks Encrypt (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07500_PARAMS, sizeof(RSA_07500_PARAMS) / sizeof(RSA_07500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_07500_PARAMS); } -static const struct HksParam RSA_07600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07600 - * @tc.name : HksRsaMtTest07600 + * @tc.number : HksRsaEcbOaepSha1Mt07600 + * @tc.name : HksRsaEcbOaepSha1Mt07600 * @tc.desc : Test huks Encrypt (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07600_PARAMS, sizeof(RSA_07600_PARAMS) / sizeof(RSA_07600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_07600_PARAMS); } -static const struct HksParam RSA_07700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07700 - * @tc.name : HksRsaMtTest07700 + * @tc.number : HksRsaEcbOaepSha1Mt07700 + * @tc.name : HksRsaEcbOaepSha1Mt07700 * @tc.desc : Test huks Encrypt (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07700_PARAMS, sizeof(RSA_07700_PARAMS) / sizeof(RSA_07700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_07700_PARAMS); } -static const struct HksParam RSA_07800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07800 - * @tc.name : HksRsaMtTest07800 + * @tc.number : HksRsaEcbOaepSha1Mt07800 + * @tc.name : HksRsaEcbOaepSha1Mt07800 * @tc.desc : Test huks Encrypt (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07800_PARAMS, sizeof(RSA_07800_PARAMS) / sizeof(RSA_07800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_07800_PARAMS); } -static const struct HksParam RSA_07900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest07900 - * @tc.name : HksRsaMtTest07900 + * @tc.number : HksRsaEcbOaepSha1Mt07900 + * @tc.name : HksRsaEcbOaepSha1Mt07900 * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest07900, TestSize.Level1) - +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt07900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_07900_PARAMS, sizeof(RSA_07900_PARAMS) / sizeof(RSA_07900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_07900_PARAMS); } -static const struct HksParam RSA_08000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08000 - * @tc.name : HksRsaMtTest08000 + * @tc.number : HksRsaEcbOaepSha1Mt08000 + * @tc.name : HksRsaEcbOaepSha1Mt08000 * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08000_PARAMS, sizeof(RSA_08000_PARAMS) / sizeof(RSA_08000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_08000_PARAMS); } -static const struct HksParam RSA_08100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08100 - * @tc.name : HksRsaMtTest08100 + * @tc.number : HksRsaEcbOaepSha1Mt08100 + * @tc.name : HksRsaEcbOaepSha1Mt08100 * @tc.desc : Test huks Decrypt (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08100, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08100_PARAMS, sizeof(RSA_08100_PARAMS) / sizeof(RSA_08100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_08100_PARAMS); } -static const struct HksParam RSA_08200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08200 - * @tc.name : HksRsaMtTest08200 + * @tc.number : HksRsaEcbOaepSha1Mt08200 + * @tc.name : HksRsaEcbOaepSha1Mt08200 * @tc.desc : Test huks Decrypt (768_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08200, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08200_PARAMS, sizeof(RSA_08200_PARAMS) / sizeof(RSA_08200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_08200_PARAMS); } -static const struct HksParam RSA_08300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08300 - * @tc.name : HksRsaMtTest08300 + * @tc.number : HksRsaEcbOaepSha1Mt08300 + * @tc.name : HksRsaEcbOaepSha1Mt08300 * @tc.desc : Test huks Decrypt (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08300, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08300_PARAMS, sizeof(RSA_08300_PARAMS) / sizeof(RSA_08300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_08300_PARAMS); } -static const struct HksParam RSA_08400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08400 - * @tc.name : HksRsaMtTest08400 + * @tc.number : HksRsaEcbOaepSha1Mt08400 + * @tc.name : HksRsaEcbOaepSha1Mt08400 * @tc.desc : Test huks Decrypt (1024_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08400_PARAMS, sizeof(RSA_08400_PARAMS) / sizeof(RSA_08400_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_08400_PARAMS); } -static const struct HksParam RSA_08500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08500 - * @tc.name : HksRsaMtTest08500 + * @tc.number : HksRsaEcbOaepSha1Mt08500 + * @tc.name : HksRsaEcbOaepSha1Mt08500 * @tc.desc : Test huks Decrypt (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08500_PARAMS, sizeof(RSA_08500_PARAMS) / sizeof(RSA_08500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_08500_PARAMS); } -static const struct HksParam RSA_08600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08600 - * @tc.name : HksRsaMtTest08600 + * @tc.number : HksRsaEcbOaepSha1Mt08600 + * @tc.name : HksRsaEcbOaepSha1Mt08600 * @tc.desc : Test huks Decrypt (2048_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08600_PARAMS, sizeof(RSA_08600_PARAMS) / sizeof(RSA_08600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_08600_PARAMS); } -static const struct HksParam RSA_08700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08700 - * @tc.name : HksRsaMtTest08700 + * @tc.number : HksRsaEcbOaepSha1Mt08700 + * @tc.name : HksRsaEcbOaepSha1Mt08700 * @tc.desc : Test huks Decrypt (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08700_PARAMS, sizeof(RSA_08700_PARAMS) / sizeof(RSA_08700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_08700_PARAMS); } -static const struct HksParam RSA_08800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08800 - * @tc.name : HksRsaMtTest08800 + * @tc.number : HksRsaEcbOaepSha1Mt08800 + * @tc.name : HksRsaEcbOaepSha1Mt08800 * @tc.desc : Test huks Decrypt (3072_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08800_PARAMS, sizeof(RSA_08800_PARAMS) / sizeof(RSA_08800_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_08800_PARAMS); } -static const struct HksParam RSA_08900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest08900 - * @tc.name : HksRsaMtTest08900 + * @tc.number : HksRsaEcbOaepSha1Mt08900 + * @tc.name : HksRsaEcbOaepSha1Mt08900 * @tc.desc : Test huks Decrypt (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest08900, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt08900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_08900_PARAMS, sizeof(RSA_08900_PARAMS) / sizeof(RSA_08900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_08900_PARAMS); } -static const struct HksParam RSA_09000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest09000 - * @tc.name : HksRsaMtTest09000 + * @tc.number : HksRsaEcbOaepSha1Mt09000 + * @tc.name : HksRsaEcbOaepSha1Mt09000 * @tc.desc : Test huks Decrypt (4096_RSA/ECB/OAEPWithSHA-1AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaMtTest09000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha1Mt, HksRsaEcbOaepSha1Mt09000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_09000_PARAMS, sizeof(RSA_09000_PARAMS) / sizeof(RSA_09000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA1), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_09000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp index 95f189b4..ee44b8c8 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha224_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,2192 +25,971 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for OAEPWithSHA-224"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace -class HksRsaEcbOaepSha224Mt : public testing::Test {}; - -static const struct HksParam RSA_09100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_09100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "01234", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest09100 - * @tc.name : HksRsaMtTest09100 - * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_09100_PARAMS, sizeof(RSA_09100_PARAMS) / sizeof(RSA_09100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "01234"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(publicKey.data); - free(privateKey.data); - free(paramSetOut); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} -static const struct HksParam RSA_09200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_09200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest09200 - * @tc.name : HksRsaMtTest09200 - * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const GenerateKeyCaseParams HKS_RSA_MT_09300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const GenerateKeyCaseParams HKS_RSA_MT_09400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_09200_PARAMS, sizeof(RSA_09200_PARAMS) / sizeof(RSA_09200_PARAMS[0])), - HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_09500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_09600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_09700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "01234", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const EncryptServiceCaseParams HKS_RSA_MT_09800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "01234", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const EncryptLocalCaseParams HKS_RSA_MT_09900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const EncryptServiceCaseParams HKS_RSA_MT_10000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const EncryptLocalCaseParams HKS_RSA_MT_10100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_10200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); +const EncryptLocalCaseParams HKS_RSA_MT_10300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); +const EncryptServiceCaseParams HKS_RSA_MT_10400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +const EncryptLocalCaseParams HKS_RSA_MT_10500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} +const EncryptServiceCaseParams HKS_RSA_MT_10600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_09300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const EncryptLocalCaseParams HKS_RSA_MT_10700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest09300 - * @tc.name : HksRsaMtTest09300 - * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_10800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const DecryptLocalCaseParams HKS_RSA_MT_10900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "012345", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_09300_PARAMS, sizeof(RSA_09300_PARAMS) / sizeof(RSA_09300_PARAMS[0])), - HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_11000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "01234", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_11100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_11200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_11300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_11400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_11500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_11600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const DecryptLocalCaseParams HKS_RSA_MT_11700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const DecryptServiceCaseParams HKS_RSA_MT_11800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const DecryptLocalCaseParams HKS_RSA_MT_11900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); +const DecryptServiceCaseParams HKS_RSA_MT_12000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); +class HksRsaEcbOaepSha224Mt : public HksRsaCommonMt, public testing::Test {}; - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +/** + * @tc.number : HksRsaEcbOaepSha224Mt09100 + * @tc.name : HksRsaEcbOaepSha224Mt09100 + * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09100_PARAMS); +} - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaEcbOaepSha224Mt09200 + * @tc.name : HksRsaEcbOaepSha224Mt09200 + * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09200_PARAMS); } -static const struct HksParam RSA_09400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaEcbOaepSha224Mt09300 + * @tc.name : HksRsaEcbOaepSha224Mt09300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_09300_PARAMS); +} /** - * @tc.number : HksRsaMtTest09400 - * @tc.name : HksRsaMtTest09400 + * @tc.number : HksRsaEcbOaepSha224Mt09400 + * @tc.name : HksRsaEcbOaepSha224Mt09400 * @tc.desc : Test huks generate key (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09400, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_09400_PARAMS, sizeof(RSA_09400_PARAMS) / sizeof(RSA_09400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_09400_PARAMS); } -static const struct HksParam RSA_09500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest09500 - * @tc.name : HksRsaMtTest09500 + * @tc.number : HksRsaEcbOaepSha224Mt09500 + * @tc.name : HksRsaEcbOaepSha224Mt09500 * @tc.desc : Test huks generate key (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_09500_PARAMS, sizeof(RSA_09500_PARAMS) / sizeof(RSA_09500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_09500_PARAMS); } -static const struct HksParam RSA_09600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest09600 - * @tc.name : HksRsaMtTest09600 + * @tc.number : HksRsaEcbOaepSha224Mt09600 + * @tc.name : HksRsaEcbOaepSha224Mt09600 * @tc.desc : Test huks generate key (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09600, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_09600_PARAMS, sizeof(RSA_09600_PARAMS) / sizeof(RSA_09600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_09600_PARAMS); } -static const struct HksParam RSA_09700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest09700 - * @tc.name : HksRsaMtTest09700 + * @tc.number : HksRsaEcbOaepSha224Mt09700 + * @tc.name : HksRsaEcbOaepSha224Mt09700 * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_09700_PARAMS, sizeof(RSA_09700_PARAMS) / sizeof(RSA_09700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "01234"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_09700_PARAMS); } -static const struct HksParam RSA_09800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest09800 - * @tc.name : HksRsaMtTest09800 + * @tc.number : HksRsaEcbOaepSha224Mt09800 + * @tc.name : HksRsaEcbOaepSha224Mt09800 * @tc.desc : Test huks Encrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_09800_PARAMS, sizeof(RSA_09800_PARAMS) / sizeof(RSA_09800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "01234"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_09800_PARAMS); } -static const struct HksParam RSA_09900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest09900 - * @tc.name : HksRsaMtTest09900 + * @tc.number : HksRsaEcbOaepSha224Mt09900 + * @tc.name : HksRsaEcbOaepSha224Mt09900 * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest09900, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt09900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_09900_PARAMS, sizeof(RSA_09900_PARAMS) / sizeof(RSA_09900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_09900_PARAMS); } -static const struct HksParam RSA_10000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest10000 - * @tc.name : HksRsaMtTest10000 + * @tc.number : HksRsaEcbOaepSha224Mt10000 + * @tc.name : HksRsaEcbOaepSha224Mt10000 * @tc.desc : Test huks Encrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10000_PARAMS, sizeof(RSA_10000_PARAMS) / sizeof(RSA_10000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_10000_PARAMS); } -static const struct HksParam RSA_10100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; /** - * @tc.number : HksRsaMtTest10100 - * @tc.name : HksRsaMtTest10100 + * @tc.number : HksRsaEcbOaepSha224Mt10100 + * @tc.name : HksRsaEcbOaepSha224Mt10100 * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10100, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10100_PARAMS, sizeof(RSA_10100_PARAMS) / sizeof(RSA_10100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_10100_PARAMS); } -static const struct HksParam RSA_10200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest10200 - * @tc.name : HksRsaMtTest10200 + * @tc.number : HksRsaEcbOaepSha224Mt10200 + * @tc.name : HksRsaEcbOaepSha224Mt10200 * @tc.desc : Test huks Encrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10200, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10200_PARAMS, sizeof(RSA_10200_PARAMS) / sizeof(RSA_10200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_10200_PARAMS); } -static const struct HksParam RSA_10300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest10300 - * @tc.name : HksRsaMtTest10300 + * @tc.number : HksRsaEcbOaepSha224Mt10300 + * @tc.name : HksRsaEcbOaepSha224Mt10300 * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10300, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10300_PARAMS, sizeof(RSA_10300_PARAMS) / sizeof(RSA_10300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_10300_PARAMS); } -static const struct HksParam RSA_10400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest10400 - * @tc.name : HksRsaMtTest10400 + * @tc.number : HksRsaEcbOaepSha224Mt10400 + * @tc.name : HksRsaEcbOaepSha224Mt10400 * @tc.desc : Test huks Encrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10400_PARAMS, sizeof(RSA_10400_PARAMS) / sizeof(RSA_10400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_10400_PARAMS); } -static const struct HksParam RSA_10500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest10500 - * @tc.name : HksRsaMtTest10500 + * @tc.number : HksRsaEcbOaepSha224Mt10500 + * @tc.name : HksRsaEcbOaepSha224Mt10500 * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10500_PARAMS, sizeof(RSA_10500_PARAMS) / sizeof(RSA_10500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_10500_PARAMS); } -static const struct HksParam RSA_10600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest10600 - * @tc.name : HksRsaMtTest10600 + * @tc.number : HksRsaEcbOaepSha224Mt10600 + * @tc.name : HksRsaEcbOaepSha224Mt10600 * @tc.desc : Test huks Encrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10600_PARAMS, sizeof(RSA_10600_PARAMS) / sizeof(RSA_10600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_10600_PARAMS); } -static const struct HksParam RSA_10700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest10700 - * @tc.name : HksRsaMtTest10700 + * @tc.number : HksRsaEcbOaepSha224Mt10700 + * @tc.name : HksRsaEcbOaepSha224Mt10700 * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10700_PARAMS, sizeof(RSA_10700_PARAMS) / sizeof(RSA_10700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_10700_PARAMS); } -static const struct HksParam RSA_10800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest10800 - * @tc.name : HksRsaMtTest10800 + * @tc.number : HksRsaEcbOaepSha224Mt10800 + * @tc.name : HksRsaEcbOaepSha224Mt10800 * @tc.desc : Test huks Encrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10800_PARAMS, sizeof(RSA_10800_PARAMS) / sizeof(RSA_10800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_10800_PARAMS); } -static const struct HksParam RSA_10900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; /** - * @tc.number : HksRsaMtTest10900 - * @tc.name : HksRsaMtTest10900 + * @tc.number : HksRsaEcbOaepSha224Mt10900 + * @tc.name : HksRsaEcbOaepSha224Mt10900 * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest10900, TestSize.Level1) - +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt10900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_10900_PARAMS, sizeof(RSA_10900_PARAMS) / sizeof(RSA_10900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "012345"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_10900_PARAMS); } -static const struct HksParam RSA_11000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11000 - * @tc.name : HksRsaMtTest11000 + * @tc.number : HksRsaEcbOaepSha224Mt11000 + * @tc.name : HksRsaEcbOaepSha224Mt11000 * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11000_PARAMS, sizeof(RSA_11000_PARAMS) / sizeof(RSA_11000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "01234"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_11000_PARAMS); } -static const struct HksParam RSA_11100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11100 - * @tc.name : HksRsaMtTest11100 + * @tc.number : HksRsaEcbOaepSha224Mt11100 + * @tc.name : HksRsaEcbOaepSha224Mt11100 * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11100, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11100_PARAMS, sizeof(RSA_11100_PARAMS) / sizeof(RSA_11100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_11100_PARAMS); } -static const struct HksParam RSA_11200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11200 - * @tc.name : HksRsaMtTest11200 + * @tc.number : HksRsaEcbOaepSha224Mt11200 + * @tc.name : HksRsaEcbOaepSha224Mt11200 * @tc.desc : Test huks Decrypt (768_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11200, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11200_PARAMS, sizeof(RSA_11200_PARAMS) / sizeof(RSA_11200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_11200_PARAMS); } -static const struct HksParam RSA_11300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11300 - * @tc.name : HksRsaMtTest11300 + * @tc.number : HksRsaEcbOaepSha224Mt11300 + * @tc.name : HksRsaEcbOaepSha224Mt11300 * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11300, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11300_PARAMS, sizeof(RSA_11300_PARAMS) / sizeof(RSA_11300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_11300_PARAMS); } -static const struct HksParam RSA_11400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11400 - * @tc.name : HksRsaMtTest11400 + * @tc.number : HksRsaEcbOaepSha224Mt11400 + * @tc.name : HksRsaEcbOaepSha224Mt11400 * @tc.desc : Test huks Decrypt (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11400, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11400_PARAMS, sizeof(RSA_11400_PARAMS) / sizeof(RSA_11400_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_11400_PARAMS); } -static const struct HksParam RSA_11500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11500 - * @tc.name : HksRsaMtTest11500 + * @tc.number : HksRsaEcbOaepSha224Mt11500 + * @tc.name : HksRsaEcbOaepSha224Mt11500 * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11500, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11500_PARAMS, sizeof(RSA_11500_PARAMS) / sizeof(RSA_11500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_11500_PARAMS); } -static const struct HksParam RSA_11600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11600 - * @tc.name : HksRsaMtTest11600 + * @tc.number : HksRsaEcbOaepSha224Mt11600 + * @tc.name : HksRsaEcbOaepSha224Mt11600 * @tc.desc : Test huks Decrypt (2048_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11600, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11600_PARAMS, sizeof(RSA_11600_PARAMS) / sizeof(RSA_11600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_11600_PARAMS); } -static const struct HksParam RSA_11700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11700 - * @tc.name : HksRsaMtTest11700 + * @tc.number : HksRsaEcbOaepSha224Mt11700 + * @tc.name : HksRsaEcbOaepSha224Mt11700 * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11700, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11700_PARAMS, sizeof(RSA_11700_PARAMS) / sizeof(RSA_11700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_11700_PARAMS); } -static const struct HksParam RSA_11800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11800 - * @tc.name : HksRsaMtTest11800 + * @tc.number : HksRsaEcbOaepSha224Mt11800 + * @tc.name : HksRsaEcbOaepSha224Mt11800 * @tc.desc : Test huks Decrypt (3072_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11800, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11800_PARAMS, sizeof(RSA_11800_PARAMS) / sizeof(RSA_11800_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_11800_PARAMS); } -static const struct HksParam RSA_11900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest11900 - * @tc.name : HksRsaMtTest11900 + * @tc.number : HksRsaEcbOaepSha224Mt11900 + * @tc.name : HksRsaEcbOaepSha224Mt11900 * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/TEMP) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest11900, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt11900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_11900_PARAMS, sizeof(RSA_11900_PARAMS) / sizeof(RSA_11900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_11900_PARAMS); } -static const struct HksParam RSA_12000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest12000 - * @tc.name : HksRsaMtTest12000 + * @tc.number : HksRsaEcbOaepSha224Mt12000 + * @tc.name : HksRsaEcbOaepSha224Mt12000 * @tc.desc : Test huks Decrypt (4096_RSA/ECB/RSA/ECB/OAEPWithSHA-224AndMGF1Padding/PERSISTENT) */ -HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaMtTest12000, TestSize.Level1) +HWTEST_F(HksRsaEcbOaepSha224Mt, HksRsaEcbOaepSha224Mt12000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_12000_PARAMS, sizeof(RSA_12000_PARAMS) / sizeof(RSA_12000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA224), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_12000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp index 5c7c6be7..2f3b4f39 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha256_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,221 +25,700 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for OAEPWithSHA-256"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace -class HksRsaEcbOaepSha256Mt : public testing::Test {}; - -static const struct HksParam RSA_12100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_12100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha256Mt12100 - * @tc.name : HksRsaEcbOaepSha256Mt12100 - * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_12100_PARAMS, sizeof(RSA_12100_PARAMS) / sizeof(RSA_12100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), RSA_FAILED); - - free(publicKey.data); - free(paramSetOut); - free(cipherText.data); - HksFreeParamSet(¶mInSet); -} +const GenerateKeyCaseParams HKS_RSA_MT_12200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_12200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_12300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha256Mt12200 - * @tc.name : HksRsaEcbOaepSha256Mt12200 - * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const GenerateKeyCaseParams HKS_RSA_MT_12400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const GenerateKeyCaseParams HKS_RSA_MT_12500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_12200_PARAMS, sizeof(RSA_12200_PARAMS) / sizeof(RSA_12200_PARAMS[0])), - HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_12600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_12700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const EncryptServiceCaseParams HKS_RSA_MT_12800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const EncryptLocalCaseParams HKS_RSA_MT_12900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const EncryptServiceCaseParams HKS_RSA_MT_13000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const EncryptLocalCaseParams HKS_RSA_MT_13100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_13200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), RSA_FAILED); +const EncryptLocalCaseParams HKS_RSA_MT_13300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); -} +const EncryptServiceCaseParams HKS_RSA_MT_13400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_12300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const EncryptLocalCaseParams HKS_RSA_MT_13500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha256Mt12300 - * @tc.name : HksRsaEcbOaepSha256Mt12300 - * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_13600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptLocalCaseParams HKS_RSA_MT_13700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_13800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const DecryptLocalCaseParams HKS_RSA_MT_13900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_12300_PARAMS, sizeof(RSA_12300_PARAMS) / sizeof(RSA_12300_PARAMS[0])), - HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_14000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_14100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_14200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_14300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_14400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_14500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_14600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const DecryptLocalCaseParams HKS_RSA_MT_14700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const DecryptServiceCaseParams HKS_RSA_MT_14800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const DecryptLocalCaseParams HKS_RSA_MT_14900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); +const DecryptServiceCaseParams HKS_RSA_MT_15000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); +class HksRsaEcbOaepSha256Mt : public HksRsaCommonMt, public testing::Test {}; - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +/** + * @tc.number : HksRsaEcbOaepSha256Mt12100 + * @tc.name : HksRsaEcbOaepSha256Mt12100 + * @tc.desc : Test huks generate key (512_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12100_PARAMS); +} - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaEcbOaepSha256Mt12200 + * @tc.name : HksRsaEcbOaepSha256Mt12200 + * @tc.desc : Test huks generate key (768_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12200_PARAMS); } -static const struct HksParam RSA_12400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaEcbOaepSha256Mt12300 + * @tc.name : HksRsaEcbOaepSha256Mt12300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_12300_PARAMS); +} /** * @tc.number : HksRsaEcbOaepSha256Mt12400 @@ -244,74 +727,9 @@ static const struct HksParam RSA_12400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12400, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_12400_PARAMS, sizeof(RSA_12400_PARAMS) / sizeof(RSA_12400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_12400_PARAMS); } -static const struct HksParam RSA_12500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt12500 * @tc.name : HksRsaEcbOaepSha256Mt12500 @@ -319,74 +737,9 @@ static const struct HksParam RSA_12500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_12500_PARAMS, sizeof(RSA_12500_PARAMS) / sizeof(RSA_12500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_12500_PARAMS); } -static const struct HksParam RSA_12600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt12600 * @tc.name : HksRsaEcbOaepSha256Mt12600 @@ -394,74 +747,9 @@ static const struct HksParam RSA_12600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12600, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_12600_PARAMS, sizeof(RSA_12600_PARAMS) / sizeof(RSA_12600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_12600_PARAMS); } -static const struct HksParam RSA_12700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt12700 * @tc.name : HksRsaEcbOaepSha256Mt12700 @@ -469,58 +757,9 @@ static const struct HksParam RSA_12700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_12700_PARAMS, sizeof(RSA_12700_PARAMS) / sizeof(RSA_12700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_12700_PARAMS); } -static const struct HksParam RSA_12800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt12800 * @tc.name : HksRsaEcbOaepSha256Mt12800 @@ -528,61 +767,9 @@ static const struct HksParam RSA_12800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_12800_PARAMS, sizeof(RSA_12800_PARAMS) / sizeof(RSA_12800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - EVP_PKEY_free(pkey); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_12800_PARAMS); } -static const struct HksParam RSA_12900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt12900 * @tc.name : HksRsaEcbOaepSha256Mt12900 @@ -590,75 +777,9 @@ static const struct HksParam RSA_12900_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt12900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_12900_PARAMS, sizeof(RSA_12900_PARAMS) / sizeof(RSA_12900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_12900_PARAMS); } -static const struct HksParam RSA_13000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13000 * @tc.name : HksRsaEcbOaepSha256Mt13000 @@ -666,70 +787,9 @@ static const struct HksParam RSA_13000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13000_PARAMS, sizeof(RSA_13000_PARAMS) / sizeof(RSA_13000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_13000_PARAMS); } -static const struct HksParam RSA_13100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13100 * @tc.name : HksRsaEcbOaepSha256Mt13100 @@ -737,75 +797,9 @@ static const struct HksParam RSA_13100_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13100_PARAMS, sizeof(RSA_13100_PARAMS) / sizeof(RSA_13100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_13100_PARAMS); } -static const struct HksParam RSA_13200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13200 * @tc.name : HksRsaEcbOaepSha256Mt13200 @@ -813,70 +807,9 @@ static const struct HksParam RSA_13200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13200_PARAMS, sizeof(RSA_13200_PARAMS) / sizeof(RSA_13200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_13200_PARAMS); } -static const struct HksParam RSA_13300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13300 * @tc.name : HksRsaEcbOaepSha256Mt13300 @@ -884,75 +817,9 @@ static const struct HksParam RSA_13300_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13300_PARAMS, sizeof(RSA_13300_PARAMS) / sizeof(RSA_13300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_13300_PARAMS); } -static const struct HksParam RSA_13400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13400 * @tc.name : HksRsaEcbOaepSha256Mt13400 @@ -960,70 +827,9 @@ static const struct HksParam RSA_13400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13400_PARAMS, sizeof(RSA_13400_PARAMS) / sizeof(RSA_13400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_13400_PARAMS); } -static const struct HksParam RSA_13500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt00100 * @tc.name : HksRsaEcbOaepSha256Mt00100 @@ -1031,75 +837,9 @@ static const struct HksParam RSA_13500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13500_PARAMS, sizeof(RSA_13500_PARAMS) / sizeof(RSA_13500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_13500_PARAMS); } -static const struct HksParam RSA_13600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13600 * @tc.name : HksRsaEcbOaepSha256Mt13600 @@ -1107,70 +847,9 @@ static const struct HksParam RSA_13600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13600_PARAMS, sizeof(RSA_13600_PARAMS) / sizeof(RSA_13600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_13600_PARAMS); } -static const struct HksParam RSA_13700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13700 * @tc.name : HksRsaEcbOaepSha256Mt13700 @@ -1178,75 +857,9 @@ static const struct HksParam RSA_13700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13700_PARAMS, sizeof(RSA_13700_PARAMS) / sizeof(RSA_13700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_13700_PARAMS); } -static const struct HksParam RSA_13800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13800 * @tc.name : HksRsaEcbOaepSha256Mt13800 @@ -1254,131 +867,19 @@ static const struct HksParam RSA_13800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13800_PARAMS, sizeof(RSA_13800_PARAMS) / sizeof(RSA_13800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_13800_PARAMS); } -static const struct HksParam RSA_13900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt13900 * @tc.name : HksRsaEcbOaepSha256Mt13900 * @tc.desc : Test huks Decrypt (512_RSA/ECB/RSA/ECB/OAEPWithSHA-256AndMGF1Padding/TEMP) */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt13900, TestSize.Level1) - { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_13900_PARAMS, sizeof(RSA_13900_PARAMS) / sizeof(RSA_13900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_13900_PARAMS); } -static const struct HksParam RSA_14000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14000 * @tc.name : HksRsaEcbOaepSha256Mt14000 @@ -1386,60 +887,9 @@ static const struct HksParam RSA_14000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14000_PARAMS, sizeof(RSA_14000_PARAMS) / sizeof(RSA_14000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_14000_PARAMS); } -static const struct HksParam RSA_14100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14100 * @tc.name : HksRsaEcbOaepSha256Mt14100 @@ -1447,74 +897,9 @@ static const struct HksParam RSA_14100_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14100_PARAMS, sizeof(RSA_14100_PARAMS) / sizeof(RSA_14100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_14100_PARAMS); } -static const struct HksParam RSA_14200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14200 * @tc.name : HksRsaEcbOaepSha256Mt14200 @@ -1522,66 +907,9 @@ static const struct HksParam RSA_14200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14200_PARAMS, sizeof(RSA_14200_PARAMS) / sizeof(RSA_14200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_14200_PARAMS); } -static const struct HksParam RSA_14300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14300 * @tc.name : HksRsaEcbOaepSha256Mt14300 @@ -1589,74 +917,9 @@ static const struct HksParam RSA_14300_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14300_PARAMS, sizeof(RSA_14300_PARAMS) / sizeof(RSA_14300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_14300_PARAMS); } -static const struct HksParam RSA_14400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14400 * @tc.name : HksRsaEcbOaepSha256Mt14400 @@ -1664,66 +927,9 @@ static const struct HksParam RSA_14400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14400_PARAMS, sizeof(RSA_14400_PARAMS) / sizeof(RSA_14400_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_14400_PARAMS); } -static const struct HksParam RSA_14500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14500 * @tc.name : HksRsaEcbOaepSha256Mt14500 @@ -1731,74 +937,9 @@ static const struct HksParam RSA_14500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14500_PARAMS, sizeof(RSA_14500_PARAMS) / sizeof(RSA_14500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_14500_PARAMS); } -static const struct HksParam RSA_14600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14600 * @tc.name : HksRsaEcbOaepSha256Mt14600 @@ -1806,66 +947,9 @@ static const struct HksParam RSA_14600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14600_PARAMS, sizeof(RSA_14600_PARAMS) / sizeof(RSA_14600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_14600_PARAMS); } -static const struct HksParam RSA_14700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14700 * @tc.name : HksRsaEcbOaepSha256Mt14700 @@ -1873,74 +957,9 @@ static const struct HksParam RSA_14700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14700_PARAMS, sizeof(RSA_14700_PARAMS) / sizeof(RSA_14700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_14700_PARAMS); } -static const struct HksParam RSA_14800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14800 * @tc.name : HksRsaEcbOaepSha256Mt14800 @@ -1948,66 +967,9 @@ static const struct HksParam RSA_14800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14800_PARAMS, sizeof(RSA_14800_PARAMS) / sizeof(RSA_14800_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_14800_PARAMS); } -static const struct HksParam RSA_14900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt14900 * @tc.name : HksRsaEcbOaepSha256Mt14900 @@ -2015,74 +977,9 @@ static const struct HksParam RSA_14900_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt14900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_14900_PARAMS, sizeof(RSA_14900_PARAMS) / sizeof(RSA_14900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_14900_PARAMS); } -static const struct HksParam RSA_15000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha256Mt15000 * @tc.name : HksRsaEcbOaepSha256Mt15000 @@ -2090,51 +987,9 @@ static const struct HksParam RSA_15000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha256Mt, HksRsaEcbOaepSha256Mt15000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_15000_PARAMS, sizeof(RSA_15000_PARAMS) / sizeof(RSA_15000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA256), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_15000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp index abb9f095..3dbeb8b2 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha384_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,206 +25,700 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for OAEPWithSHA-384"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace -class HksRsaEcbOaepSha384Mt : public testing::Test {}; - -static const struct HksParam RSA_15100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_15100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha384Mt15100 - * @tc.name : HksRsaEcbOaepSha384Mt15100 - * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_15100_PARAMS, sizeof(RSA_15100_PARAMS) / sizeof(RSA_15100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); - - free(publicKey.data); - free(paramSetOut); - free(cipherText.data); - HksFreeParamSet(¶mInSet); -} +const GenerateKeyCaseParams HKS_RSA_MT_15200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_15200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_15300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha384Mt15200 - * @tc.name : HksRsaEcbOaepSha384Mt15200 - * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const GenerateKeyCaseParams HKS_RSA_MT_15400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const GenerateKeyCaseParams HKS_RSA_MT_15500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const GenerateKeyCaseParams HKS_RSA_MT_15600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_15200_PARAMS, sizeof(RSA_15200_PARAMS) / sizeof(RSA_15200_PARAMS[0])), - HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_15700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const EncryptServiceCaseParams HKS_RSA_MT_15800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_15900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; + +const EncryptServiceCaseParams HKS_RSA_MT_16000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const EncryptLocalCaseParams HKS_RSA_MT_16100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const EncryptServiceCaseParams HKS_RSA_MT_16200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const EncryptLocalCaseParams HKS_RSA_MT_16300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_16400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); +const EncryptLocalCaseParams HKS_RSA_MT_16500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); -} +const EncryptServiceCaseParams HKS_RSA_MT_16600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_15300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const EncryptLocalCaseParams HKS_RSA_MT_16700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha384Mt15300 - * @tc.name : HksRsaEcbOaepSha384Mt15300 - * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_16800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const DecryptLocalCaseParams HKS_RSA_MT_16900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_15300_PARAMS, sizeof(RSA_15300_PARAMS) / sizeof(RSA_15300_PARAMS[0])), - HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_17000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_17100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_17200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_17300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_17400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const DecryptLocalCaseParams HKS_RSA_MT_17500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const DecryptServiceCaseParams HKS_RSA_MT_17600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const DecryptLocalCaseParams HKS_RSA_MT_17700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); +const DecryptServiceCaseParams HKS_RSA_MT_17800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); -} +const DecryptLocalCaseParams HKS_RSA_MT_17900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_15400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const DecryptServiceCaseParams HKS_RSA_MT_18000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; +} // namespace + +class HksRsaEcbOaepSha384Mt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15100 + * @tc.name : HksRsaEcbOaepSha384Mt15100 + * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15200 + * @tc.name : HksRsaEcbOaepSha384Mt15200 + * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha384Mt15300 + * @tc.name : HksRsaEcbOaepSha384Mt15300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_15300_PARAMS); +} /** * @tc.number : HksRsaEcbOaepSha384Mt15400 @@ -229,74 +727,9 @@ static const struct HksParam RSA_15400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15400, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_15400_PARAMS, sizeof(RSA_15400_PARAMS) / sizeof(RSA_15400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_15400_PARAMS); } -static const struct HksParam RSA_15500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt15500 * @tc.name : HksRsaEcbOaepSha384Mt15500 @@ -304,74 +737,9 @@ static const struct HksParam RSA_15500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_15500_PARAMS, sizeof(RSA_15500_PARAMS) / sizeof(RSA_15500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_15500_PARAMS); } -static const struct HksParam RSA_15600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt15600 * @tc.name : HksRsaEcbOaepSha384Mt15600 @@ -379,74 +747,9 @@ static const struct HksParam RSA_15600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15600, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_15600_PARAMS, sizeof(RSA_15600_PARAMS) / sizeof(RSA_15600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_15600_PARAMS); } -static const struct HksParam RSA_15700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt15700 * @tc.name : HksRsaEcbOaepSha384Mt15700 @@ -454,59 +757,9 @@ static const struct HksParam RSA_15700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_15700_PARAMS, sizeof(RSA_15700_PARAMS) / sizeof(RSA_15700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_15700_PARAMS); } -static const struct HksParam RSA_15800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt15800 * @tc.name : HksRsaEcbOaepSha384Mt15800 @@ -514,61 +767,9 @@ static const struct HksParam RSA_15800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_15800_PARAMS, sizeof(RSA_15800_PARAMS) / sizeof(RSA_15800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - EVP_PKEY_free(pkey); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_15800_PARAMS); } -static const struct HksParam RSA_15900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt15900 * @tc.name : HksRsaEcbOaepSha384Mt15900 @@ -576,59 +777,9 @@ static const struct HksParam RSA_15900_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt15900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_15900_PARAMS, sizeof(RSA_15900_PARAMS) / sizeof(RSA_15900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_15900_PARAMS); } -static const struct HksParam RSA_16000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16000 * @tc.name : HksRsaEcbOaepSha384Mt16000 @@ -636,61 +787,9 @@ static const struct HksParam RSA_16000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16000_PARAMS, sizeof(RSA_16000_PARAMS) / sizeof(RSA_16000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - EVP_PKEY_free(pkey); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_16000_PARAMS); } -static const struct HksParam RSA_16100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16100 * @tc.name : HksRsaEcbOaepSha384Mt16100 @@ -698,75 +797,9 @@ static const struct HksParam RSA_16100_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16100_PARAMS, sizeof(RSA_16100_PARAMS) / sizeof(RSA_16100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_16100_PARAMS); } -static const struct HksParam RSA_16200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16200 * @tc.name : HksRsaEcbOaepSha384Mt16200 @@ -774,70 +807,9 @@ static const struct HksParam RSA_16200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16200_PARAMS, sizeof(RSA_16200_PARAMS) / sizeof(RSA_16200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_16200_PARAMS); } -static const struct HksParam RSA_16300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16300 * @tc.name : HksRsaEcbOaepSha384Mt16300 @@ -845,75 +817,9 @@ static const struct HksParam RSA_16300_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16300_PARAMS, sizeof(RSA_16300_PARAMS) / sizeof(RSA_16300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_16300_PARAMS); } -static const struct HksParam RSA_16400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16400 * @tc.name : HksRsaEcbOaepSha384Mt16400 @@ -921,70 +827,9 @@ static const struct HksParam RSA_16400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16400_PARAMS, sizeof(RSA_16400_PARAMS) / sizeof(RSA_16400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_16400_PARAMS); } -static const struct HksParam RSA_16500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16500 * @tc.name : HksRsaEcbOaepSha384Mt16500 @@ -992,75 +837,9 @@ static const struct HksParam RSA_16500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16500_PARAMS, sizeof(RSA_16500_PARAMS) / sizeof(RSA_16500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_16500_PARAMS); } -static const struct HksParam RSA_16600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16600 * @tc.name : HksRsaEcbOaepSha384Mt16600 @@ -1068,70 +847,9 @@ static const struct HksParam RSA_16600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16600_PARAMS, sizeof(RSA_16600_PARAMS) / sizeof(RSA_16600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_16600_PARAMS); } -static const struct HksParam RSA_16700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16700 * @tc.name : HksRsaEcbOaepSha384Mt16700 @@ -1139,75 +857,9 @@ static const struct HksParam RSA_16700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16700_PARAMS, sizeof(RSA_16700_PARAMS) / sizeof(RSA_16700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_16700_PARAMS); } -static const struct HksParam RSA_16800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16800 * @tc.name : HksRsaEcbOaepSha384Mt16800 @@ -1215,131 +867,19 @@ static const struct HksParam RSA_16800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16800_PARAMS, sizeof(RSA_16800_PARAMS) / sizeof(RSA_16800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_16800_PARAMS); } -static const struct HksParam RSA_16900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt16900 * @tc.name : HksRsaEcbOaepSha384Mt16900 * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-384AndMGF1Padding/TEMP) */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt16900, TestSize.Level1) - { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_16900_PARAMS, sizeof(RSA_16900_PARAMS) / sizeof(RSA_16900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_16900_PARAMS); } -static const struct HksParam RSA_17000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17000 * @tc.name : HksRsaEcbOaepSha384Mt17000 @@ -1347,60 +887,9 @@ static const struct HksParam RSA_17000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17000_PARAMS, sizeof(RSA_17000_PARAMS) / sizeof(RSA_17000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_17000_PARAMS); } -static const struct HksParam RSA_17100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17100 * @tc.name : HksRsaEcbOaepSha384Mt17100 @@ -1408,59 +897,9 @@ static const struct HksParam RSA_17100_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17100_PARAMS, sizeof(RSA_17100_PARAMS) / sizeof(RSA_17100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_17100_PARAMS); } -static const struct HksParam RSA_17200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17200 * @tc.name : HksRsaEcbOaepSha384Mt17200 @@ -1468,60 +907,9 @@ static const struct HksParam RSA_17200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17200_PARAMS, sizeof(RSA_17200_PARAMS) / sizeof(RSA_17200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_17200_PARAMS); } -static const struct HksParam RSA_17300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17300 * @tc.name : HksRsaEcbOaepSha384Mt17300 @@ -1529,74 +917,9 @@ static const struct HksParam RSA_17300_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17300_PARAMS, sizeof(RSA_17300_PARAMS) / sizeof(RSA_17300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_17300_PARAMS); } -static const struct HksParam RSA_17400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17400 * @tc.name : HksRsaEcbOaepSha384Mt17400 @@ -1604,66 +927,9 @@ static const struct HksParam RSA_17400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17400_PARAMS, sizeof(RSA_17400_PARAMS) / sizeof(RSA_17400_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_17400_PARAMS); } -static const struct HksParam RSA_17500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17500 * @tc.name : HksRsaEcbOaepSha384Mt17500 @@ -1671,74 +937,9 @@ static const struct HksParam RSA_17500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17500_PARAMS, sizeof(RSA_17500_PARAMS) / sizeof(RSA_17500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_17500_PARAMS); } -static const struct HksParam RSA_17600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17600 * @tc.name : HksRsaEcbOaepSha384Mt17600 @@ -1746,66 +947,9 @@ static const struct HksParam RSA_17600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17600_PARAMS, sizeof(RSA_17600_PARAMS) / sizeof(RSA_17600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_17600_PARAMS); } -static const struct HksParam RSA_17700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17700 * @tc.name : HksRsaEcbOaepSha384Mt17700 @@ -1813,74 +957,9 @@ static const struct HksParam RSA_17700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17700_PARAMS, sizeof(RSA_17700_PARAMS) / sizeof(RSA_17700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_17700_PARAMS); } -static const struct HksParam RSA_17800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17800 * @tc.name : HksRsaEcbOaepSha384Mt17800 @@ -1888,66 +967,9 @@ static const struct HksParam RSA_17800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17800_PARAMS, sizeof(RSA_17800_PARAMS) / sizeof(RSA_17800_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_17800_PARAMS); } -static const struct HksParam RSA_17900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt17900 * @tc.name : HksRsaEcbOaepSha384Mt17900 @@ -1955,74 +977,9 @@ static const struct HksParam RSA_17900_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt17900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_17900_PARAMS, sizeof(RSA_17900_PARAMS) / sizeof(RSA_17900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_17900_PARAMS); } -static const struct HksParam RSA_18000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha384Mt18000 * @tc.name : HksRsaEcbOaepSha384Mt18000 @@ -2030,51 +987,9 @@ static const struct HksParam RSA_18000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha384Mt, HksRsaEcbOaepSha384Mt18000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_18000_PARAMS, sizeof(RSA_18000_PARAMS) / sizeof(RSA_18000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA384), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_18000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp index 92f70aa0..702ebde2 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_oaep_sha512_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,207 +25,701 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for OAEPWithSHA-512"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace -class HksRsaEcbOaepSha512Mt : public testing::Test {}; - -static const struct HksParam RSA_18100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_18100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha512Mt18100 - * @tc.name : HksRsaEcbOaepSha512Mt18100 - * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_18100_PARAMS, sizeof(RSA_18100_PARAMS) / sizeof(RSA_18100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(publicKey.data); - free(paramSetOut); - free(cipherText.data); - HksFreeParamSet(¶mInSet); -} +const GenerateKeyCaseParams HKS_RSA_MT_18200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_18200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_18300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha512Mt18200 - * @tc.name : HksRsaEcbOaepSha512Mt18200 - * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const GenerateKeyCaseParams HKS_RSA_MT_18400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const GenerateKeyCaseParams HKS_RSA_MT_18500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_18200_PARAMS, sizeof(RSA_18200_PARAMS) / sizeof(RSA_18200_PARAMS[0])), - HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_18600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_18700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const EncryptServiceCaseParams HKS_RSA_MT_18800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const EncryptLocalCaseParams HKS_RSA_MT_18900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const EncryptServiceCaseParams HKS_RSA_MT_19000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const EncryptLocalCaseParams HKS_RSA_MT_19100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_19200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_ERROR_INVALID_KEY_FILE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); +const EncryptLocalCaseParams HKS_RSA_MT_19300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); -} +const EncryptServiceCaseParams HKS_RSA_MT_19400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_18300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const EncryptLocalCaseParams HKS_RSA_MT_19500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbOaepSha512Mt18300 - * @tc.name : HksRsaEcbOaepSha512Mt18300 - * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) - */ -HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const EncryptServiceCaseParams HKS_RSA_MT_19600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const EncryptLocalCaseParams HKS_RSA_MT_19700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_18300_PARAMS, sizeof(RSA_18300_PARAMS) / sizeof(RSA_18300_PARAMS[0])), - HKS_SUCCESS); +const EncryptServiceCaseParams HKS_RSA_MT_19800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_19900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_20000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_20100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_20200_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const DecryptLocalCaseParams HKS_RSA_MT_20300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const DecryptServiceCaseParams HKS_RSA_MT_20400_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_FAILURE, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const DecryptLocalCaseParams HKS_RSA_MT_20500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); +const DecryptServiceCaseParams HKS_RSA_MT_20600_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); -} +const DecryptLocalCaseParams HKS_RSA_MT_20700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; + +const DecryptServiceCaseParams HKS_RSA_MT_20800_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_18400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const DecryptLocalCaseParams HKS_RSA_MT_20900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; +const DecryptServiceCaseParams HKS_RSA_MT_21000_PARAMS = { + .alias = "This is a test auth id for OAEPWithSHA-512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_OAEP_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace + +class HksRsaEcbOaepSha512Mt : public HksRsaCommonMt, public testing::Test {}; + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18100 + * @tc.name : HksRsaEcbOaepSha512Mt18100 + * @tc.desc : Test huks generate key (512_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18100_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18200 + * @tc.name : HksRsaEcbOaepSha512Mt18200 + * @tc.desc : Test huks generate key (768_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18200_PARAMS); +} + +/** + * @tc.number : HksRsaEcbOaepSha512Mt18300 + * @tc.name : HksRsaEcbOaepSha512Mt18300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) + */ +HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_18300_PARAMS); +} + /** * @tc.number : HksRsaEcbOaepSha512Mt18400 * @tc.name : HksRsaEcbOaepSha512Mt18400 @@ -229,74 +727,9 @@ static const struct HksParam RSA_18400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18400, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_18400_PARAMS, sizeof(RSA_18400_PARAMS) / sizeof(RSA_18400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_18400_PARAMS); } -static const struct HksParam RSA_18500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt18500 * @tc.name : HksRsaEcbOaepSha512Mt18500 @@ -304,74 +737,9 @@ static const struct HksParam RSA_18500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_18500_PARAMS, sizeof(RSA_18500_PARAMS) / sizeof(RSA_18500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_18500_PARAMS); } -static const struct HksParam RSA_18600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt18600 * @tc.name : HksRsaEcbOaepSha512Mt18600 @@ -379,74 +747,9 @@ static const struct HksParam RSA_18600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18600, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_18600_PARAMS, sizeof(RSA_18600_PARAMS) / sizeof(RSA_18600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_18600_PARAMS); } -static const struct HksParam RSA_18700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt18700 * @tc.name : HksRsaEcbOaepSha512Mt18700 @@ -454,59 +757,9 @@ static const struct HksParam RSA_18700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_18700_PARAMS, sizeof(RSA_18700_PARAMS) / sizeof(RSA_18700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_18700_PARAMS); } -static const struct HksParam RSA_18800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt18800 * @tc.name : HksRsaEcbOaepSha512Mt18800 @@ -514,61 +767,9 @@ static const struct HksParam RSA_18800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_18800_PARAMS, sizeof(RSA_18800_PARAMS) / sizeof(RSA_18800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - EVP_PKEY_free(pkey); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_18800_PARAMS); } -static const struct HksParam RSA_18900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt18900 * @tc.name : HksRsaEcbOaepSha512Mt18900 @@ -576,59 +777,9 @@ static const struct HksParam RSA_18900_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt18900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_18900_PARAMS, sizeof(RSA_18900_PARAMS) / sizeof(RSA_18900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_18900_PARAMS); } -static const struct HksParam RSA_19000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19000 * @tc.name : HksRsaEcbOaepSha512Mt19000 @@ -636,61 +787,9 @@ static const struct HksParam RSA_19000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19000_PARAMS, sizeof(RSA_19000_PARAMS) / sizeof(RSA_19000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - EVP_PKEY_free(pkey); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_19000_PARAMS); } -static const struct HksParam RSA_19100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19100 * @tc.name : HksRsaEcbOaepSha512Mt19100 @@ -698,59 +797,9 @@ static const struct HksParam RSA_19100_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19100_PARAMS, sizeof(RSA_19100_PARAMS) / sizeof(RSA_19100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_19100_PARAMS); } -static const struct HksParam RSA_19200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19200 * @tc.name : HksRsaEcbOaepSha512Mt19200 @@ -758,61 +807,9 @@ static const struct HksParam RSA_19200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19200_PARAMS, sizeof(RSA_19200_PARAMS) / sizeof(RSA_19200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_ERROR_INVALID_KEY_FILE); - - EVP_PKEY_free(pkey); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_19200_PARAMS); } -static const struct HksParam RSA_19300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19300 * @tc.name : HksRsaEcbOaepSha512Mt19300 @@ -820,75 +817,9 @@ static const struct HksParam RSA_19300_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19300_PARAMS, sizeof(RSA_19300_PARAMS) / sizeof(RSA_19300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_19300_PARAMS); } -static const struct HksParam RSA_19400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19400 * @tc.name : HksRsaEcbOaepSha512Mt19400 @@ -896,70 +827,9 @@ static const struct HksParam RSA_19400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19400_PARAMS, sizeof(RSA_19400_PARAMS) / sizeof(RSA_19400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_19400_PARAMS); } -static const struct HksParam RSA_19500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19500 * @tc.name : HksRsaEcbOaepSha512Mt19500 @@ -967,75 +837,9 @@ static const struct HksParam RSA_19500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19500_PARAMS, sizeof(RSA_19500_PARAMS) / sizeof(RSA_19500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_19500_PARAMS); } -static const struct HksParam RSA_19600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19600 * @tc.name : HksRsaEcbOaepSha512Mt19600 @@ -1043,70 +847,9 @@ static const struct HksParam RSA_19600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19600_PARAMS, sizeof(RSA_19600_PARAMS) / sizeof(RSA_19600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_19600_PARAMS); } -static const struct HksParam RSA_19700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19700 * @tc.name : HksRsaEcbOaepSha512Mt19700 @@ -1114,75 +857,9 @@ static const struct HksParam RSA_19700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19700_PARAMS, sizeof(RSA_19700_PARAMS) / sizeof(RSA_19700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_19700_PARAMS); } -static const struct HksParam RSA_19800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19800 * @tc.name : HksRsaEcbOaepSha512Mt19800 @@ -1190,131 +867,19 @@ static const struct HksParam RSA_19800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19800_PARAMS, sizeof(RSA_19800_PARAMS) / sizeof(RSA_19800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_19800_PARAMS); } -static const struct HksParam RSA_19900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt19900 * @tc.name : HksRsaEcbOaepSha512Mt19900 * @tc.desc : Test huks Decrypt (512_RSA/ECB/OAEPWithSHA-512AndMGF1Padding/TEMP) */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt19900, TestSize.Level1) - { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_19900_PARAMS, sizeof(RSA_19900_PARAMS) / sizeof(RSA_19900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_19900_PARAMS); } -static const struct HksParam RSA_20000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20000 * @tc.name : HksRsaEcbOaepSha512Mt20000 @@ -1322,60 +887,9 @@ static const struct HksParam RSA_20000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20000_PARAMS, sizeof(RSA_20000_PARAMS) / sizeof(RSA_20000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_20000_PARAMS); } -static const struct HksParam RSA_20100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20100 * @tc.name : HksRsaEcbOaepSha512Mt20100 @@ -1383,59 +897,9 @@ static const struct HksParam RSA_20100_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20100_PARAMS, sizeof(RSA_20100_PARAMS) / sizeof(RSA_20100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_20100_PARAMS); } -static const struct HksParam RSA_20200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20200 * @tc.name : HksRsaEcbOaepSha512Mt20200 @@ -1443,60 +907,9 @@ static const struct HksParam RSA_20200_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20200_PARAMS, sizeof(RSA_20200_PARAMS) / sizeof(RSA_20200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_20200_PARAMS); } -static const struct HksParam RSA_20300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20300 * @tc.name : HksRsaEcbOaepSha512Mt20300 @@ -1504,59 +917,9 @@ static const struct HksParam RSA_20300_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20300_PARAMS, sizeof(RSA_20300_PARAMS) / sizeof(RSA_20300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_20300_PARAMS); } -static const struct HksParam RSA_20400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20400 * @tc.name : HksRsaEcbOaepSha512Mt20400 @@ -1564,60 +927,9 @@ static const struct HksParam RSA_20400_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20400_PARAMS, sizeof(RSA_20400_PARAMS) / sizeof(RSA_20400_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_20400_PARAMS); } -static const struct HksParam RSA_20500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20500 * @tc.name : HksRsaEcbOaepSha512Mt20500 @@ -1625,74 +937,9 @@ static const struct HksParam RSA_20500_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20500_PARAMS, sizeof(RSA_20500_PARAMS) / sizeof(RSA_20500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_20500_PARAMS); } -static const struct HksParam RSA_20600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20600 * @tc.name : HksRsaEcbOaepSha512Mt20600 @@ -1700,66 +947,9 @@ static const struct HksParam RSA_20600_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20600_PARAMS, sizeof(RSA_20600_PARAMS) / sizeof(RSA_20600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_20600_PARAMS); } -static const struct HksParam RSA_20700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20700 * @tc.name : HksRsaEcbOaepSha512Mt20700 @@ -1767,74 +957,9 @@ static const struct HksParam RSA_20700_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20700_PARAMS, sizeof(RSA_20700_PARAMS) / sizeof(RSA_20700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_20700_PARAMS); } -static const struct HksParam RSA_20800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20800 * @tc.name : HksRsaEcbOaepSha512Mt20800 @@ -1842,66 +967,9 @@ static const struct HksParam RSA_20800_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20800_PARAMS, sizeof(RSA_20800_PARAMS) / sizeof(RSA_20800_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_20800_PARAMS); } -static const struct HksParam RSA_20900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt20900 * @tc.name : HksRsaEcbOaepSha512Mt20900 @@ -1909,74 +977,9 @@ static const struct HksParam RSA_20900_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt20900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_20900_PARAMS, sizeof(RSA_20900_PARAMS) / sizeof(RSA_20900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_20900_PARAMS); } -static const struct HksParam RSA_21000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbOaepSha512Mt21000 * @tc.name : HksRsaEcbOaepSha512Mt21000 @@ -1984,51 +987,9 @@ static const struct HksParam RSA_21000_PARAMS[] = { */ HWTEST_F(HksRsaEcbOaepSha512Mt, HksRsaEcbOaepSha512Mt21000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_21000_PARAMS, sizeof(RSA_21000_PARAMS) / sizeof(RSA_21000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_OAEP_PADDING, HKS_DIGEST_SHA512), 0); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_21000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp index db6c852b..74c727a2 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_ecb_pkcs1_padding_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,251 +25,703 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for PKCS1Padding"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace -class HksRsaEcbPkcs1PaddingMt : public testing::Test {}; - -static const struct HksParam RSA_21100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_21100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbPkcs1PaddingMt21100 - * @tc.name : HksRsaEcbPkcs1PaddingMt21100 - * @tc.desc : Test huks generate key (512_RSA/ECB/PKCS1Padding/TEMP) - */ - -HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_21100_PARAMS, sizeof(RSA_21100_PARAMS) / sizeof(RSA_21100_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(publicKey.data); - free(privateKey.data); - free(paramSetOut); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} -static const struct HksParam RSA_21200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const GenerateKeyCaseParams HKS_RSA_MT_21200_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbPkcs1PaddingMt21200 - * @tc.name : HksRsaEcbPkcs1PaddingMt21200 - * @tc.desc : Test huks generate key (768_RSA/ECB/PKCS1Padding/TEMP) - */ +const GenerateKeyCaseParams HKS_RSA_MT_21300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21200, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const GenerateKeyCaseParams HKS_RSA_MT_21400_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const GenerateKeyCaseParams HKS_RSA_MT_21500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_21200_PARAMS, sizeof(RSA_21200_PARAMS) / sizeof(RSA_21200_PARAMS[0])), - HKS_SUCCESS); +const GenerateKeyCaseParams HKS_RSA_MT_21600_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_21700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const EncryptServiceCaseParams HKS_RSA_MT_21800_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const EncryptLocalCaseParams HKS_RSA_MT_21900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const EncryptServiceCaseParams HKS_RSA_MT_22000_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const EncryptLocalCaseParams HKS_RSA_MT_22100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const EncryptServiceCaseParams HKS_RSA_MT_22200_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +const EncryptLocalCaseParams HKS_RSA_MT_22300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); +const EncryptServiceCaseParams HKS_RSA_MT_22400_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); +const EncryptLocalCaseParams HKS_RSA_MT_22500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +const EncryptServiceCaseParams HKS_RSA_MT_22600_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); -} +const EncryptLocalCaseParams HKS_RSA_MT_22700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_21300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const EncryptServiceCaseParams HKS_RSA_MT_22800_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaEcbPkcs1PaddingMt21300 - * @tc.name : HksRsaEcbPkcs1PaddingMt21300 - * @tc.desc : Test huks generate key (1024_RSA/ECB/PKCS1Padding/TEMP) - */ +const DecryptLocalCaseParams HKS_RSA_MT_22900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; -HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const DecryptServiceCaseParams HKS_RSA_MT_23000_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const DecryptLocalCaseParams HKS_RSA_MT_23100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_21300_PARAMS, sizeof(RSA_21300_PARAMS) / sizeof(RSA_21300_PARAMS[0])), - HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_23200_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_23300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const DecryptServiceCaseParams HKS_RSA_MT_23400_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_23500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_23600_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const DecryptLocalCaseParams HKS_RSA_MT_23700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const DecryptServiceCaseParams HKS_RSA_MT_23800_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const DecryptLocalCaseParams HKS_RSA_MT_23900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const DecryptServiceCaseParams HKS_RSA_MT_24000_PARAMS = { + .alias = "This is a test auth id for PKCS1Padding", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .hexData = "00112233445566778899aabbccddeeff", + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .encryptResult = HKS_SUCCESS, + .decryptResult = HKS_SUCCESS, +}; +} // namespace - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); +class HksRsaEcbPkcs1PaddingMt : public HksRsaCommonMt, public testing::Test {}; - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21100 + * @tc.name : HksRsaEcbPkcs1PaddingMt21100 + * @tc.desc : Test huks generate key (512_RSA/ECB/PKCS1Padding/TEMP) + */ - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21100, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21100_PARAMS); +} - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21200 + * @tc.name : HksRsaEcbPkcs1PaddingMt21200 + * @tc.desc : Test huks generate key (768_RSA/ECB/PKCS1Padding/TEMP) + */ - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21200, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21200_PARAMS); } -static const struct HksParam RSA_21400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaEcbPkcs1PaddingMt21300 + * @tc.name : HksRsaEcbPkcs1PaddingMt21300 + * @tc.desc : Test huks generate key (1024_RSA/ECB/PKCS1Padding/TEMP) + */ + +HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21300, TestSize.Level1) +{ + GenerateKeyTestCase(HKS_RSA_MT_21300_PARAMS); +} /** * @tc.number : HksRsaEcbPkcs1PaddingMt21400 @@ -275,74 +731,9 @@ static const struct HksParam RSA_21400_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21400, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_21400_PARAMS, sizeof(RSA_21400_PARAMS) / sizeof(RSA_21400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_21400_PARAMS); } -static const struct HksParam RSA_21500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt21500 * @tc.name : HksRsaEcbPkcs1PaddingMt21500 @@ -351,74 +742,9 @@ static const struct HksParam RSA_21500_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_21500_PARAMS, sizeof(RSA_21500_PARAMS) / sizeof(RSA_21500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_21500_PARAMS); } -static const struct HksParam RSA_21600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt21600 * @tc.name : HksRsaEcbPkcs1PaddingMt21600 @@ -427,74 +753,9 @@ static const struct HksParam RSA_21600_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21600, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_21600_PARAMS, sizeof(RSA_21600_PARAMS) / sizeof(RSA_21600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + GenerateKeyTestCase(HKS_RSA_MT_21600_PARAMS); } -static const struct HksParam RSA_21700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt21700 * @tc.name : HksRsaEcbPkcs1PaddingMt21700 @@ -503,75 +764,9 @@ static const struct HksParam RSA_21700_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_21700_PARAMS, sizeof(RSA_21700_PARAMS) / sizeof(RSA_21700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_21700_PARAMS); } -static const struct HksParam RSA_21800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt21800 * @tc.name : HksRsaEcbPkcs1PaddingMt21800 @@ -580,70 +775,9 @@ static const struct HksParam RSA_21800_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_21800_PARAMS, sizeof(RSA_21800_PARAMS) / sizeof(RSA_21800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_21800_PARAMS); } -static const struct HksParam RSA_21900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt21900 * @tc.name : HksRsaEcbPkcs1PaddingMt21900 @@ -651,75 +785,9 @@ static const struct HksParam RSA_21900_PARAMS[] = { */ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt21900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_21900_PARAMS, sizeof(RSA_21900_PARAMS) / sizeof(RSA_21900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_21900_PARAMS); } -static const struct HksParam RSA_22000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22000 * @tc.name : HksRsaEcbPkcs1PaddingMt22000 @@ -728,70 +796,9 @@ static const struct HksParam RSA_22000_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22000_PARAMS, sizeof(RSA_22000_PARAMS) / sizeof(RSA_22000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_22000_PARAMS); } -static const struct HksParam RSA_22100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22100 * @tc.name : HksRsaEcbPkcs1PaddingMt22100 @@ -800,75 +807,9 @@ static const struct HksParam RSA_22100_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22100_PARAMS, sizeof(RSA_22100_PARAMS) / sizeof(RSA_22100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_22100_PARAMS); } -static const struct HksParam RSA_22200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22200 * @tc.name : HksRsaEcbPkcs1PaddingMt22200 @@ -877,70 +818,9 @@ static const struct HksParam RSA_22200_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22200_PARAMS, sizeof(RSA_22200_PARAMS) / sizeof(RSA_22200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_22200_PARAMS); } -static const struct HksParam RSA_22300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22300 * @tc.name : HksRsaEcbPkcs1PaddingMt22300 @@ -949,75 +829,9 @@ static const struct HksParam RSA_22300_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22300_PARAMS, sizeof(RSA_22300_PARAMS) / sizeof(RSA_22300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_22300_PARAMS); } -static const struct HksParam RSA_22400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22400 * @tc.name : HksRsaEcbPkcs1PaddingMt22400 @@ -1026,70 +840,9 @@ static const struct HksParam RSA_22400_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22400_PARAMS, sizeof(RSA_22400_PARAMS) / sizeof(RSA_22400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_22400_PARAMS); } -static const struct HksParam RSA_22500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22500 * @tc.name : HksRsaEcbPkcs1PaddingMt22500 @@ -1098,75 +851,9 @@ static const struct HksParam RSA_22500_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22500_PARAMS, sizeof(RSA_22500_PARAMS) / sizeof(RSA_22500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_22500_PARAMS); } -static const struct HksParam RSA_22600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22600 * @tc.name : HksRsaEcbPkcs1PaddingMt22600 @@ -1175,70 +862,9 @@ static const struct HksParam RSA_22600_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22600_PARAMS, sizeof(RSA_22600_PARAMS) / sizeof(RSA_22600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_22600_PARAMS); } -static const struct HksParam RSA_22700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22700 * @tc.name : HksRsaEcbPkcs1PaddingMt22700 @@ -1247,75 +873,9 @@ static const struct HksParam RSA_22700_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22700_PARAMS, sizeof(RSA_22700_PARAMS) / sizeof(RSA_22700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(HksEncrypt(&publicKey, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - EXPECT_EQ(DecryptRSA(&cipherText, &decryptedText, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + EncryptLocalTestCase(HKS_RSA_MT_22700_PARAMS); } -static const struct HksParam RSA_22800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22800 * @tc.name : HksRsaEcbPkcs1PaddingMt22800 @@ -1324,70 +884,9 @@ static const struct HksParam RSA_22800_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22800_PARAMS, sizeof(RSA_22800_PARAMS) / sizeof(RSA_22800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLen = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLen, .data = (uint8_t *)malloc(inLen) }; - ASSERT_NE(cipherText.data, nullptr); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - - EXPECT_EQ(HksEncrypt(&authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); - - EXPECT_EQ( - DecryptRSA(&cipherText, &decryptedText, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - EVP_PKEY_free(pkey); - free(decryptedText.data); - free(cipherText.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + EncryptServiceTestCase(HKS_RSA_MT_22800_PARAMS); } -static const struct HksParam RSA_22900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt22900 * @tc.name : HksRsaEcbPkcs1PaddingMt22900 @@ -1395,76 +894,10 @@ static const struct HksParam RSA_22900_PARAMS[] = { */ HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt22900, TestSize.Level1) - { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_22900_PARAMS, sizeof(RSA_22900_PARAMS) / sizeof(RSA_22900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_22900_PARAMS); } -static const struct HksParam RSA_23000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23000 * @tc.name : HksRsaEcbPkcs1PaddingMt23000 @@ -1473,66 +906,9 @@ static const struct HksParam RSA_23000_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23000_PARAMS, sizeof(RSA_23000_PARAMS) / sizeof(RSA_23000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_23000_PARAMS); } -static const struct HksParam RSA_23100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23100 * @tc.name : HksRsaEcbPkcs1PaddingMt23100 @@ -1541,74 +917,9 @@ static const struct HksParam RSA_23100_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23100_PARAMS, sizeof(RSA_23100_PARAMS) / sizeof(RSA_23100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_23100_PARAMS); } -static const struct HksParam RSA_23200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23200 * @tc.name : HksRsaEcbPkcs1PaddingMt23200 @@ -1617,66 +928,9 @@ static const struct HksParam RSA_23200_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23200_PARAMS, sizeof(RSA_23200_PARAMS) / sizeof(RSA_23200_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_23200_PARAMS); } -static const struct HksParam RSA_23300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23300 * @tc.name : HksRsaEcbPkcs1PaddingMt23300 @@ -1685,74 +939,9 @@ static const struct HksParam RSA_23300_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23300_PARAMS, sizeof(RSA_23300_PARAMS) / sizeof(RSA_23300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_23300_PARAMS); } -static const struct HksParam RSA_23400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23400 * @tc.name : HksRsaEcbPkcs1PaddingMt23400 @@ -1761,66 +950,9 @@ static const struct HksParam RSA_23400_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23400_PARAMS, sizeof(RSA_23400_PARAMS) / sizeof(RSA_23400_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_23400_PARAMS); } -static const struct HksParam RSA_23500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23500 * @tc.name : HksRsaEcbPkcs1PaddingMt23500 @@ -1829,74 +961,9 @@ static const struct HksParam RSA_23500_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23500_PARAMS, sizeof(RSA_23500_PARAMS) / sizeof(RSA_23500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_23500_PARAMS); } -static const struct HksParam RSA_23600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23600 * @tc.name : HksRsaEcbPkcs1PaddingMt23600 @@ -1905,66 +972,9 @@ static const struct HksParam RSA_23600_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23600_PARAMS, sizeof(RSA_23600_PARAMS) / sizeof(RSA_23600_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_23600_PARAMS); } -static const struct HksParam RSA_23700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23700 * @tc.name : HksRsaEcbPkcs1PaddingMt23700 @@ -1973,74 +983,9 @@ static const struct HksParam RSA_23700_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23700_PARAMS, sizeof(RSA_23700_PARAMS) / sizeof(RSA_23700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_23700_PARAMS); } -static const struct HksParam RSA_23800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23800 * @tc.name : HksRsaEcbPkcs1PaddingMt23800 @@ -2049,66 +994,9 @@ static const struct HksParam RSA_23800_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23800_PARAMS, sizeof(RSA_23800_PARAMS) / sizeof(RSA_23800_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_23800_PARAMS); } -static const struct HksParam RSA_23900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt23900 * @tc.name : HksRsaEcbPkcs1PaddingMt23900 @@ -2117,74 +1005,9 @@ static const struct HksParam RSA_23900_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt23900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_23900_PARAMS, sizeof(RSA_23900_PARAMS) / sizeof(RSA_23900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&privateKey, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptLocalTestCase(HKS_RSA_MT_23900_PARAMS); } -static const struct HksParam RSA_24000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** * @tc.number : HksRsaEcbPkcs1PaddingMt24000 * @tc.name : HksRsaEcbPkcs1PaddingMt24000 @@ -2193,51 +1016,9 @@ static const struct HksParam RSA_24000_PARAMS[] = { HWTEST_F(HksRsaEcbPkcs1PaddingMt, HksRsaEcbPkcs1PaddingMt24000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24000_PARAMS, sizeof(RSA_24000_PARAMS) / sizeof(RSA_24000_PARAMS[0])), - HKS_SUCCESS); - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - HksParam *cipherLenBit = NULL; - HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &cipherLenBit); - uint32_t inLength = (cipherLenBit->uint32Param) / BIT_NUM_OF_UINT8; - HksBlob cipherText = { .size = inLength, .data = (uint8_t *)malloc(inLength) }; - ASSERT_NE(cipherText.data, nullptr); - EXPECT_EQ(EncryptRSA(&plainText, &cipherText, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), RSA_SUCCESS); - HksBlob decryptedText = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(decryptedText.data, nullptr); - EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &decryptedText), HKS_SUCCESS); - - EXPECT_EQ((memcmp(plainText.data, decryptedText.data, decryptedText.size)), 0); - - free(paramSetOut); - free(publicKey.data); - free(cipherText.data); - free(decryptedText.data); - HksFreeParamSet(¶mInSet); + DecryptServiceTestCase(HKS_RSA_MT_24000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp index 64b960f3..5934d1e7 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_md5_with_rsa_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1576 +25,759 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for MD5"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaMd5WithRsaMt : public testing::Test {}; -static const struct HksParam RSA_24100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_24100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest24100 - * @tc.name : HksRsaMtTest24100 - * @tc.desc : Test huks sign (512/MD5withRSA/TEMP) - */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24100_PARAMS, sizeof(RSA_24100_PARAMS) / sizeof(RSA_24100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_24200_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_24300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_24400_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_24500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_24600_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_24700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_24800_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_24900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); +const SignServiceCaseParams HKS_RSA_MT_25000_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_25100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_24200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_25200_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest24200 - * @tc.name : HksRsaMtTest24200 - * @tc.desc : Test huks sign (512/MD5withRSA/PERSISTENT) - */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_25300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_25400_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_24200_PARAMS, sizeof(RSA_24200_PARAMS) / sizeof(RSA_24200_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_25500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_25600_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_25700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_25800_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_25900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_26000_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_26100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_26200_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_26300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_26400_PARAMS = { + .alias = "This is a test auth id for MD5", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_MD5, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); +class HksRsaMd5WithRsaMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaMd5WithRsaMt24100 + * @tc.name : HksRsaMd5WithRsaMt24100 + * @tc.desc : Test huks sign (512/MD5withRSA/TEMP) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_24100_PARAMS); } -static const struct HksParam RSA_24300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaMd5WithRsaMt24200 + * @tc.name : HksRsaMd5WithRsaMt24200 + * @tc.desc : Test huks sign (512/MD5withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_24200_PARAMS); +} /** - * @tc.number : HksRsaMtTest24300 - * @tc.name : HksRsaMtTest24300 + * @tc.number : HksRsaMd5WithRsaMt24300 + * @tc.name : HksRsaMd5WithRsaMt24300 * @tc.desc : Test huks Verify (512/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24300, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24300_PARAMS, sizeof(RSA_24300_PARAMS) / sizeof(RSA_24300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_24300_PARAMS); } -static const struct HksParam RSA_24400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest24400 - * @tc.name : HksRsaMtTest24400 + * @tc.number : HksRsaMd5WithRsaMt24400 + * @tc.name : HksRsaMd5WithRsaMt24400 * @tc.desc : Test huks Verify (512/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24400, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24400_PARAMS, sizeof(RSA_24400_PARAMS) / sizeof(RSA_24400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_24400_PARAMS); } -static const struct HksParam RSA_24500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest24500 - * @tc.name : HksRsaMtTest24500 + * @tc.number : HksRsaMd5WithRsaMt24500 + * @tc.name : HksRsaMd5WithRsaMt24500 * @tc.desc : Test huks sign (768/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24500, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24500_PARAMS, sizeof(RSA_24500_PARAMS) / sizeof(RSA_24500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_24500_PARAMS); } -static const struct HksParam RSA_24600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest24600 - * @tc.name : HksRsaMtTest24600 + * @tc.number : HksRsaMd5WithRsaMt24600 + * @tc.name : HksRsaMd5WithRsaMt24600 * @tc.desc : Test huks sign (768/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24600, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24600_PARAMS, sizeof(RSA_24600_PARAMS) / sizeof(RSA_24600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_24600_PARAMS); } -static const struct HksParam RSA_24700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest24700 - * @tc.name : HksRsaMtTest24700 + * @tc.number : HksRsaMd5WithRsaMt24700 + * @tc.name : HksRsaMd5WithRsaMt24700 * @tc.desc : Test huks Verify (768/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24700, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24700_PARAMS, sizeof(RSA_24700_PARAMS) / sizeof(RSA_24700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_24700_PARAMS); } -static const struct HksParam RSA_24800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest24800 - * @tc.name : HksRsaMtTest24800 + * @tc.number : HksRsaMd5WithRsaMt24800 + * @tc.name : HksRsaMd5WithRsaMt24800 * @tc.desc : Test huks Verify (768/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24800, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24800_PARAMS, sizeof(RSA_24800_PARAMS) / sizeof(RSA_24800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_24800_PARAMS); } -static const struct HksParam RSA_24900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest24900 - * @tc.name : HksRsaMtTest24900 + * @tc.number : HksRsaMd5WithRsaMt24900 + * @tc.name : HksRsaMd5WithRsaMt24900 * @tc.desc : Test huks sign (1024/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest24900, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt24900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_24900_PARAMS, sizeof(RSA_24900_PARAMS) / sizeof(RSA_24900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_24900_PARAMS); } -static const struct HksParam RSA_25000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25000 - * @tc.name : HksRsaMtTest25000 + * @tc.number : HksRsaMd5WithRsaMt25000 + * @tc.name : HksRsaMd5WithRsaMt25000 * @tc.desc : Test huks sign (1024/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25000, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25000_PARAMS, sizeof(RSA_25000_PARAMS) / sizeof(RSA_25000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_25000_PARAMS); } -static const struct HksParam RSA_25100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25100 - * @tc.name : HksRsaMtTest25100 + * @tc.number : HksRsaMd5WithRsaMt25100 + * @tc.name : HksRsaMd5WithRsaMt25100 * @tc.desc : Test huks Verify (1024/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25100, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25100_PARAMS, sizeof(RSA_25100_PARAMS) / sizeof(RSA_25100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_25100_PARAMS); } -static const struct HksParam RSA_25200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25200 - * @tc.name : HksRsaMtTest25200 + * @tc.number : HksRsaMd5WithRsaMt25200 + * @tc.name : HksRsaMd5WithRsaMt25200 * @tc.desc : Test huks Verify (1024/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25200, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25200_PARAMS, sizeof(RSA_25200_PARAMS) / sizeof(RSA_25200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_25200_PARAMS); } -static const struct HksParam RSA_25300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25300 - * @tc.name : HksRsaMtTest25300 + * @tc.number : HksRsaMd5WithRsaMt25300 + * @tc.name : HksRsaMd5WithRsaMt25300 * @tc.desc : Test huks sign (2048/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25300, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25300_PARAMS, sizeof(RSA_25300_PARAMS) / sizeof(RSA_25300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_25300_PARAMS); } -static const struct HksParam RSA_25400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25400 - * @tc.name : HksRsaMtTest25400 + * @tc.number : HksRsaMd5WithRsaMt25400 + * @tc.name : HksRsaMd5WithRsaMt25400 * @tc.desc : Test huks sign (2048/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25400, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25400_PARAMS, sizeof(RSA_25400_PARAMS) / sizeof(RSA_25400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_25400_PARAMS); } -static const struct HksParam RSA_25500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25500 - * @tc.name : HksRsaMtTest25500 + * @tc.number : HksRsaMd5WithRsaMt25500 + * @tc.name : HksRsaMd5WithRsaMt25500 * @tc.desc : Test huks Verify (2048/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25500, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25500_PARAMS, sizeof(RSA_25500_PARAMS) / sizeof(RSA_25500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_25500_PARAMS); } -static const struct HksParam RSA_25600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25600 - * @tc.name : HksRsaMtTest25600 + * @tc.number : HksRsaMd5WithRsaMt25600 + * @tc.name : HksRsaMd5WithRsaMt25600 * @tc.desc : Test huks Verify (2048/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25600, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25600_PARAMS, sizeof(RSA_25600_PARAMS) / sizeof(RSA_25600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_25600_PARAMS); } -static const struct HksParam RSA_25700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25700 - * @tc.name : HksRsaMtTest25700 + * @tc.number : HksRsaMd5WithRsaMt25700 + * @tc.name : HksRsaMd5WithRsaMt25700 * @tc.desc : Test huks sign (3072/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25700, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25700_PARAMS, sizeof(RSA_25700_PARAMS) / sizeof(RSA_25700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_25700_PARAMS); } -static const struct HksParam RSA_25800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25800 - * @tc.name : HksRsaMtTest25800 + * @tc.number : HksRsaMd5WithRsaMt25800 + * @tc.name : HksRsaMd5WithRsaMt25800 * @tc.desc : Test huks sign (3072/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25800, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25800_PARAMS, sizeof(RSA_25800_PARAMS) / sizeof(RSA_25800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_25800_PARAMS); } -static const struct HksParam RSA_25900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest25900 - * @tc.name : HksRsaMtTest25900 + * @tc.number : HksRsaMd5WithRsaMt25900 + * @tc.name : HksRsaMd5WithRsaMt25900 * @tc.desc : Test huks Verify (3072/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest25900, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt25900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_25900_PARAMS, sizeof(RSA_25900_PARAMS) / sizeof(RSA_25900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_25900_PARAMS); } -static const struct HksParam RSA_26000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest26000 - * @tc.name : HksRsaMtTest26000 + * @tc.number : HksRsaMd5WithRsaMt26000 + * @tc.name : HksRsaMd5WithRsaMt26000 * @tc.desc : Test huks Verify (3072/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26000, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26000_PARAMS, sizeof(RSA_26000_PARAMS) / sizeof(RSA_26000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_26000_PARAMS); } -static const struct HksParam RSA_26100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest26100 - * @tc.name : HksRsaMtTest26100 + * @tc.number : HksRsaMd5WithRsaMt26100 + * @tc.name : HksRsaMd5WithRsaMt26100 * @tc.desc : Test huks sign (4096/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26100, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26100_PARAMS, sizeof(RSA_26100_PARAMS) / sizeof(RSA_26100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_26100_PARAMS); } -static const struct HksParam RSA_26200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest26200 - * @tc.name : HksRsaMtTest26200 + * @tc.number : HksRsaMd5WithRsaMt26200 + * @tc.name : HksRsaMd5WithRsaMt26200 * @tc.desc : Test huks sign (4096/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26200, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26200_PARAMS, sizeof(RSA_26200_PARAMS) / sizeof(RSA_26200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_26200_PARAMS); } -static const struct HksParam RSA_26300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest26300 - * @tc.name : HksRsaMtTest26300 + * @tc.number : HksRsaMd5WithRsaMt26300 + * @tc.name : HksRsaMd5WithRsaMt26300 * @tc.desc : Test huks Verify (4096/MD5withRSA/TEMP) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26300, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26300_PARAMS, sizeof(RSA_26300_PARAMS) / sizeof(RSA_26300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_26300_PARAMS); } -static const struct HksParam RSA_26400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest26400 - * @tc.name : HksRsaMtTest26400 + * @tc.number : HksRsaMd5WithRsaMt26400 + * @tc.name : HksRsaMd5WithRsaMt26400 * @tc.desc : Test huks Verify (4096/MD5withRSA/PERSISTENT) */ -HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMtTest26400, TestSize.Level1) +HWTEST_F(HksRsaMd5WithRsaMt, HksRsaMd5WithRsaMt26400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26400_PARAMS, sizeof(RSA_26400_PARAMS) / sizeof(RSA_26400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_MD5), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_26400_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp index b27e3298..c3ce2fef 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_none_with_rsa_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1576 +25,759 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for NONE"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaNoneWithRsaMt : public testing::Test {}; -static const struct HksParam RSA_26500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_26500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest26500 - * @tc.name : HksRsaMtTest26500 - * @tc.desc : Test huks sign (512/NONEwithRSA/TEMP) - */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26500, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26500_PARAMS, sizeof(RSA_26500_PARAMS) / sizeof(RSA_26500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_26600_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_26700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_26800_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_26900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_27000_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_27100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_27200_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_27300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); +const SignServiceCaseParams HKS_RSA_MT_27400_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_27500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_26600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_27600_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest26600 - * @tc.name : HksRsaMtTest26600 - * @tc.desc : Test huks sign (512/NONEwithRSA/PERSISTENT) - */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_27700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_27800_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_26600_PARAMS, sizeof(RSA_26600_PARAMS) / sizeof(RSA_26600_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_27900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_28000_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_28100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_28200_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_28300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_28400_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_28500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_28600_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_28700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_28800_PARAMS = { + .alias = "This is a test auth id for NONE", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_NONE, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); +class HksRsaNoneWithRsaMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaNoneWithRsaMt26500 + * @tc.name : HksRsaNoneWithRsaMt26500 + * @tc.desc : Test huks sign (512/NONEwithRSA/TEMP) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_26500_PARAMS); } -static const struct HksParam RSA_26700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaNoneWithRsaMt26600 + * @tc.name : HksRsaNoneWithRsaMt26600 + * @tc.desc : Test huks sign (512/NONEwithRSA/PERSISTENT) + */ +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_26600_PARAMS); +} /** - * @tc.number : HksRsaMtTest26700 - * @tc.name : HksRsaMtTest26700 + * @tc.number : HksRsaNoneWithRsaMt26700 + * @tc.name : HksRsaNoneWithRsaMt26700 * @tc.desc : Test huks Verify (512/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26700, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26700_PARAMS, sizeof(RSA_26700_PARAMS) / sizeof(RSA_26700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_26700_PARAMS); } -static const struct HksParam RSA_26800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest26800 - * @tc.name : HksRsaMtTest26800 + * @tc.number : HksRsaNoneWithRsaMt26800 + * @tc.name : HksRsaNoneWithRsaMt26800 * @tc.desc : Test huks Verify (512/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26800, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26800_PARAMS, sizeof(RSA_26800_PARAMS) / sizeof(RSA_26800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_26800_PARAMS); } -static const struct HksParam RSA_26900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest26900 - * @tc.name : HksRsaMtTest26900 + * @tc.number : HksRsaNoneWithRsaMt26900 + * @tc.name : HksRsaNoneWithRsaMt26900 * @tc.desc : Test huks sign (768/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest26900, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt26900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_26900_PARAMS, sizeof(RSA_26900_PARAMS) / sizeof(RSA_26900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_26900_PARAMS); } -static const struct HksParam RSA_27000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27000 - * @tc.name : HksRsaMtTest27000 + * @tc.number : HksRsaNoneWithRsaMt27000 + * @tc.name : HksRsaNoneWithRsaMt27000 * @tc.desc : Test huks sign (768/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27000, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27000_PARAMS, sizeof(RSA_27000_PARAMS) / sizeof(RSA_27000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_27000_PARAMS); } -static const struct HksParam RSA_27100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27100 - * @tc.name : HksRsaMtTest27100 + * @tc.number : HksRsaNoneWithRsaMt27100 + * @tc.name : HksRsaNoneWithRsaMt27100 * @tc.desc : Test huks Verify (768/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27100, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27100_PARAMS, sizeof(RSA_27100_PARAMS) / sizeof(RSA_27100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_27100_PARAMS); } -static const struct HksParam RSA_27200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27200 - * @tc.name : HksRsaMtTest27200 + * @tc.number : HksRsaNoneWithRsaMt27200 + * @tc.name : HksRsaNoneWithRsaMt27200 * @tc.desc : Test huks Verify (768/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27200, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27200_PARAMS, sizeof(RSA_27200_PARAMS) / sizeof(RSA_27200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_27200_PARAMS); } -static const struct HksParam RSA_27300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27300 - * @tc.name : HksRsaMtTest27300 + * @tc.number : HksRsaNoneWithRsaMt27300 + * @tc.name : HksRsaNoneWithRsaMt27300 * @tc.desc : Test huks sign (1024/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27300, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27300_PARAMS, sizeof(RSA_27300_PARAMS) / sizeof(RSA_27300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_27300_PARAMS); } -static const struct HksParam RSA_27400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27400 - * @tc.name : HksRsaMtTest27400 + * @tc.number : HksRsaNoneWithRsaMt27400 + * @tc.name : HksRsaNoneWithRsaMt27400 * @tc.desc : Test huks sign (1024/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27400, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27400_PARAMS, sizeof(RSA_27400_PARAMS) / sizeof(RSA_27400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_27400_PARAMS); } -static const struct HksParam RSA_27500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27500 - * @tc.name : HksRsaMtTest27500 + * @tc.number : HksRsaNoneWithRsaMt27500 + * @tc.name : HksRsaNoneWithRsaMt27500 * @tc.desc : Test huks Verify (1024/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27500, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27500_PARAMS, sizeof(RSA_27500_PARAMS) / sizeof(RSA_27500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_27500_PARAMS); } -static const struct HksParam RSA_27600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27600 - * @tc.name : HksRsaMtTest27600 + * @tc.number : HksRsaNoneWithRsaMt27600 + * @tc.name : HksRsaNoneWithRsaMt27600 * @tc.desc : Test huks Verify (1024/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27600, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27600_PARAMS, sizeof(RSA_27600_PARAMS) / sizeof(RSA_27600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_27600_PARAMS); } -static const struct HksParam RSA_27700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27700 - * @tc.name : HksRsaMtTest27700 + * @tc.number : HksRsaNoneWithRsaMt27700 + * @tc.name : HksRsaNoneWithRsaMt27700 * @tc.desc : Test huks sign (2048/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27700, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27700_PARAMS, sizeof(RSA_27700_PARAMS) / sizeof(RSA_27700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_27700_PARAMS); } -static const struct HksParam RSA_27800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27800 - * @tc.name : HksRsaMtTest27800 + * @tc.number : HksRsaNoneWithRsaMt27800 + * @tc.name : HksRsaNoneWithRsaMt27800 * @tc.desc : Test huks sign (2048/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27800, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27800_PARAMS, sizeof(RSA_27800_PARAMS) / sizeof(RSA_27800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_27800_PARAMS); } -static const struct HksParam RSA_27900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest27900 - * @tc.name : HksRsaMtTest27900 + * @tc.number : HksRsaNoneWithRsaMt27900 + * @tc.name : HksRsaNoneWithRsaMt27900 * @tc.desc : Test huks Verify (2048/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest27900, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt27900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_27900_PARAMS, sizeof(RSA_27900_PARAMS) / sizeof(RSA_27900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_27900_PARAMS); } -static const struct HksParam RSA_28000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28000 - * @tc.name : HksRsaMtTest28000 + * @tc.number : HksRsaNoneWithRsaMt28000 + * @tc.name : HksRsaNoneWithRsaMt28000 * @tc.desc : Test huks Verify (2048/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28000, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28000_PARAMS, sizeof(RSA_28000_PARAMS) / sizeof(RSA_28000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_28000_PARAMS); } -static const struct HksParam RSA_28100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28100 - * @tc.name : HksRsaMtTest28100 + * @tc.number : HksRsaNoneWithRsaMt28100 + * @tc.name : HksRsaNoneWithRsaMt28100 * @tc.desc : Test huks sign (3072/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28100, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28100_PARAMS, sizeof(RSA_28100_PARAMS) / sizeof(RSA_28100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_28100_PARAMS); } -static const struct HksParam RSA_28200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28200 - * @tc.name : HksRsaMtTest28200 + * @tc.number : HksRsaNoneWithRsaMt28200 + * @tc.name : HksRsaNoneWithRsaMt28200 * @tc.desc : Test huks sign (3072/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28200, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28200_PARAMS, sizeof(RSA_28200_PARAMS) / sizeof(RSA_28200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_28200_PARAMS); } -static const struct HksParam RSA_28300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28300 - * @tc.name : HksRsaMtTest28300 + * @tc.number : HksRsaNoneWithRsaMt28300 + * @tc.name : HksRsaNoneWithRsaMt28300 * @tc.desc : Test huks Verify (3072/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28300, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28300_PARAMS, sizeof(RSA_28300_PARAMS) / sizeof(RSA_28300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_28300_PARAMS); } -static const struct HksParam RSA_28400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28400 - * @tc.name : HksRsaMtTest28400 + * @tc.number : HksRsaNoneWithRsaMt28400 + * @tc.name : HksRsaNoneWithRsaMt28400 * @tc.desc : Test huks Verify (3072/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28400, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28400_PARAMS, sizeof(RSA_28400_PARAMS) / sizeof(RSA_28400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_28400_PARAMS); } -static const struct HksParam RSA_28500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28500 - * @tc.name : HksRsaMtTest28500 + * @tc.number : HksRsaNoneWithRsaMt28500 + * @tc.name : HksRsaNoneWithRsaMt28500 * @tc.desc : Test huks sign (4096/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28500, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28500_PARAMS, sizeof(RSA_28500_PARAMS) / sizeof(RSA_28500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_28500_PARAMS); } -static const struct HksParam RSA_28600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28600 - * @tc.name : HksRsaMtTest28600 + * @tc.number : HksRsaNoneWithRsaMt28600 + * @tc.name : HksRsaNoneWithRsaMt28600 * @tc.desc : Test huks sign (4096/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28600, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28600_PARAMS, sizeof(RSA_28600_PARAMS) / sizeof(RSA_28600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_28600_PARAMS); } -static const struct HksParam RSA_28700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28700 - * @tc.name : HksRsaMtTest28700 + * @tc.number : HksRsaNoneWithRsaMt28700 + * @tc.name : HksRsaNoneWithRsaMt28700 * @tc.desc : Test huks Verify (4096/NONEwithRSA/TEMP) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28700, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28700_PARAMS, sizeof(RSA_28700_PARAMS) / sizeof(RSA_28700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_28700_PARAMS); } -static const struct HksParam RSA_28800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest28800 - * @tc.name : HksRsaMtTest28800 + * @tc.number : HksRsaNoneWithRsaMt28800 + * @tc.name : HksRsaNoneWithRsaMt28800 * @tc.desc : Test huks Verify (4096/NONEwithRSA/PERSISTENT) */ -HWTEST_F(HksRsaNoneWithRsaMt, HksRsaMtTest28800, TestSize.Level1) +HWTEST_F(HksRsaNoneWithRsaMt, HksRsaNoneWithRsaMt28800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28800_PARAMS, sizeof(RSA_28800_PARAMS) / sizeof(RSA_28800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_NONE), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_28800_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp index c4f17bcc..02886e8a 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1576 +25,759 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA1"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha1WithRsaMt : public testing::Test {}; -static const struct HksParam RSA_28900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_28900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest28900 - * @tc.name : HksRsaMtTest28900 - * @tc.desc : Test huks sign (512/SHA1withRSA/TEMP) - */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest28900, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_28900_PARAMS, sizeof(RSA_28900_PARAMS) / sizeof(RSA_28900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_29000_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_29100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_29200_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_29300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_29400_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_29500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_29600_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_29700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); +const SignServiceCaseParams HKS_RSA_MT_29800_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_29900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_29000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_30000_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest29000 - * @tc.name : HksRsaMtTest29000 - * @tc.desc : Test huks sign (512/SHA1withRSA/PERSISTENT) - */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_30100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_30200_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_29000_PARAMS, sizeof(RSA_29000_PARAMS) / sizeof(RSA_29000_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_30300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_30400_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_30500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_30600_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_30700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_30800_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_30900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_31000_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_31100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_31200_PARAMS = { + .alias = "This is a test auth id for SHA1", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); +class HksRsaSha1WithRsaMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha1WithRsaMt28900 + * @tc.name : HksRsaSha1WithRsaMt28900 + * @tc.desc : Test huks sign (512/SHA1withRSA/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt28900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_28900_PARAMS); } -static const struct HksParam RSA_29100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha1WithRsaMt29000 + * @tc.name : HksRsaSha1WithRsaMt29000 + * @tc.desc : Test huks sign (512/SHA1withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_29000_PARAMS); +} /** - * @tc.number : HksRsaMtTest29100 - * @tc.name : HksRsaMtTest29100 + * @tc.number : HksRsaSha1WithRsaMt29100 + * @tc.name : HksRsaSha1WithRsaMt29100 * @tc.desc : Test huks Verify (512/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29100, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29100_PARAMS, sizeof(RSA_29100_PARAMS) / sizeof(RSA_29100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_29100_PARAMS); } -static const struct HksParam RSA_29200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest29200 - * @tc.name : HksRsaMtTest29200 + * @tc.number : HksRsaSha1WithRsaMt29200 + * @tc.name : HksRsaSha1WithRsaMt29200 * @tc.desc : Test huks Verify (512/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29200, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29200_PARAMS, sizeof(RSA_29200_PARAMS) / sizeof(RSA_29200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_29200_PARAMS); } -static const struct HksParam RSA_29300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest29300 - * @tc.name : HksRsaMtTest29300 + * @tc.number : HksRsaSha1WithRsaMt29300 + * @tc.name : HksRsaSha1WithRsaMt29300 * @tc.desc : Test huks sign (768/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29300, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29300_PARAMS, sizeof(RSA_29300_PARAMS) / sizeof(RSA_29300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_29300_PARAMS); } -static const struct HksParam RSA_29400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest29400 - * @tc.name : HksRsaMtTest29400 + * @tc.number : HksRsaSha1WithRsaMt29400 + * @tc.name : HksRsaSha1WithRsaMt29400 * @tc.desc : Test huks sign (768/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29400, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29400_PARAMS, sizeof(RSA_29400_PARAMS) / sizeof(RSA_29400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_29400_PARAMS); } -static const struct HksParam RSA_29500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest29500 - * @tc.name : HksRsaMtTest29500 + * @tc.number : HksRsaSha1WithRsaMt29500 + * @tc.name : HksRsaSha1WithRsaMt29500 * @tc.desc : Test huks Verify (768/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29500, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29500_PARAMS, sizeof(RSA_29500_PARAMS) / sizeof(RSA_29500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_29500_PARAMS); } -static const struct HksParam RSA_29600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest29600 - * @tc.name : HksRsaMtTest29600 + * @tc.number : HksRsaSha1WithRsaMt29600 + * @tc.name : HksRsaSha1WithRsaMt29600 * @tc.desc : Test huks Verify (768/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29600, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29600_PARAMS, sizeof(RSA_29600_PARAMS) / sizeof(RSA_29600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_29600_PARAMS); } -static const struct HksParam RSA_29700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest29700 - * @tc.name : HksRsaMtTest29700 + * @tc.number : HksRsaSha1WithRsaMt29700 + * @tc.name : HksRsaSha1WithRsaMt29700 * @tc.desc : Test huks sign (1024/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29700, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29700_PARAMS, sizeof(RSA_29700_PARAMS) / sizeof(RSA_29700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_29700_PARAMS); } -static const struct HksParam RSA_29800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest29800 - * @tc.name : HksRsaMtTest29800 + * @tc.number : HksRsaSha1WithRsaMt29800 + * @tc.name : HksRsaSha1WithRsaMt29800 * @tc.desc : Test huks sign (1024/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29800, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29800_PARAMS, sizeof(RSA_29800_PARAMS) / sizeof(RSA_29800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_29800_PARAMS); } -static const struct HksParam RSA_29900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest29900 - * @tc.name : HksRsaMtTest29900 + * @tc.number : HksRsaSha1WithRsaMt29900 + * @tc.name : HksRsaSha1WithRsaMt29900 * @tc.desc : Test huks Verify (1024/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest29900, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt29900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_29900_PARAMS, sizeof(RSA_29900_PARAMS) / sizeof(RSA_29900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_29900_PARAMS); } -static const struct HksParam RSA_30000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30000 - * @tc.name : HksRsaMtTest30000 + * @tc.number : HksRsaSha1WithRsaMt30000 + * @tc.name : HksRsaSha1WithRsaMt30000 * @tc.desc : Test huks Verify (1024/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30000, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30000_PARAMS, sizeof(RSA_30000_PARAMS) / sizeof(RSA_30000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_30000_PARAMS); } -static const struct HksParam RSA_30100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30100 - * @tc.name : HksRsaMtTest30100 + * @tc.number : HksRsaSha1WithRsaMt30100 + * @tc.name : HksRsaSha1WithRsaMt30100 * @tc.desc : Test huks sign (2048/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30100, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30100_PARAMS, sizeof(RSA_30100_PARAMS) / sizeof(RSA_30100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_30100_PARAMS); } -static const struct HksParam RSA_30200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30200 - * @tc.name : HksRsaMtTest30200 + * @tc.number : HksRsaSha1WithRsaMt30200 + * @tc.name : HksRsaSha1WithRsaMt30200 * @tc.desc : Test huks sign (2048/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30200, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30200_PARAMS, sizeof(RSA_30200_PARAMS) / sizeof(RSA_30200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_30200_PARAMS); } -static const struct HksParam RSA_30300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30300 - * @tc.name : HksRsaMtTest30300 + * @tc.number : HksRsaSha1WithRsaMt30300 + * @tc.name : HksRsaSha1WithRsaMt30300 * @tc.desc : Test huks Verify (2048/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30300, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30300_PARAMS, sizeof(RSA_30300_PARAMS) / sizeof(RSA_30300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_30300_PARAMS); } -static const struct HksParam RSA_30400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30400 - * @tc.name : HksRsaMtTest30400 + * @tc.number : HksRsaSha1WithRsaMt30400 + * @tc.name : HksRsaSha1WithRsaMt30400 * @tc.desc : Test huks Verify (2048/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30400, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30400_PARAMS, sizeof(RSA_30400_PARAMS) / sizeof(RSA_30400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_30400_PARAMS); } -static const struct HksParam RSA_30500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30500 - * @tc.name : HksRsaMtTest30500 + * @tc.number : HksRsaSha1WithRsaMt30500 + * @tc.name : HksRsaSha1WithRsaMt30500 * @tc.desc : Test huks sign (3072/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30500, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30500_PARAMS, sizeof(RSA_30500_PARAMS) / sizeof(RSA_30500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_30500_PARAMS); } -static const struct HksParam RSA_30600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30600 - * @tc.name : HksRsaMtTest30600 + * @tc.number : HksRsaSha1WithRsaMt30600 + * @tc.name : HksRsaSha1WithRsaMt30600 * @tc.desc : Test huks sign (3072/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30600, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30600_PARAMS, sizeof(RSA_30600_PARAMS) / sizeof(RSA_30600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_30600_PARAMS); } -static const struct HksParam RSA_30700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30700 - * @tc.name : HksRsaMtTest30700 + * @tc.number : HksRsaSha1WithRsaMt30700 + * @tc.name : HksRsaSha1WithRsaMt30700 * @tc.desc : Test huks Verify (3072/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30700, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30700_PARAMS, sizeof(RSA_30700_PARAMS) / sizeof(RSA_30700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_30700_PARAMS); } -static const struct HksParam RSA_30800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30800 - * @tc.name : HksRsaMtTest30800 + * @tc.number : HksRsaSha1WithRsaMt30800 + * @tc.name : HksRsaSha1WithRsaMt30800 * @tc.desc : Test huks Verify (3072/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30800, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30800_PARAMS, sizeof(RSA_30800_PARAMS) / sizeof(RSA_30800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_30800_PARAMS); } -static const struct HksParam RSA_30900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest30900 - * @tc.name : HksRsaMtTest30900 + * @tc.number : HksRsaSha1WithRsaMt30900 + * @tc.name : HksRsaSha1WithRsaMt30900 * @tc.desc : Test huks sign (4096/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest30900, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt30900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_30900_PARAMS, sizeof(RSA_30900_PARAMS) / sizeof(RSA_30900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_30900_PARAMS); } -static const struct HksParam RSA_31000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest31000 - * @tc.name : HksRsaMtTest31000 + * @tc.number : HksRsaSha1WithRsaMt31000 + * @tc.name : HksRsaSha1WithRsaMt31000 * @tc.desc : Test huks sign (4096/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest31000, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt31000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31000_PARAMS, sizeof(RSA_31000_PARAMS) / sizeof(RSA_31000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_31000_PARAMS); } -static const struct HksParam RSA_31100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest31100 - * @tc.name : HksRsaMtTest31100 + * @tc.number : HksRsaSha1WithRsaMt31100 + * @tc.name : HksRsaSha1WithRsaMt31100 * @tc.desc : Test huks Verify (4096/SHA1withRSA/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest31100, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt31100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31100_PARAMS, sizeof(RSA_31100_PARAMS) / sizeof(RSA_31100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_31100_PARAMS); } -static const struct HksParam RSA_31200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest31200 - * @tc.name : HksRsaMtTest31200 + * @tc.number : HksRsaSha1WithRsaMt31200 + * @tc.name : HksRsaSha1WithRsaMt31200 * @tc.desc : Test huks Verify (4096/SHA1withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaMt, HksRsaMtTest31200, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaMt, HksRsaSha1WithRsaMt31200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31200_PARAMS, sizeof(RSA_31200_PARAMS) / sizeof(RSA_31200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_31200_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp index e7800bbd..a8babfbe 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha1_with_rsa_pss_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1576 +25,759 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha1AndPss"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha1WithRsaPssMt : public testing::Test {}; -static const struct HksParam RSA_31300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_31300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest31300 - * @tc.name : HksRsaMtTest31300 - * @tc.desc : Test huks sign (512/SHA1withRSA/PSS/TEMP) - */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31300_PARAMS, sizeof(RSA_31300_PARAMS) / sizeof(RSA_31300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_31400_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_31500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_31600_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_31700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_31800_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_31900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_32000_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_32100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); +const SignServiceCaseParams HKS_RSA_MT_32200_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_32300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_31400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_32400_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest31400 - * @tc.name : HksRsaMtTest31400 - * @tc.desc : Test huks sign (512/SHA1withRSA/PSS/PERSISTENT) - */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_32500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_32600_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_31400_PARAMS, sizeof(RSA_31400_PARAMS) / sizeof(RSA_31400_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_32700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_32800_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_32900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_33000_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_33100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_33200_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_33300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_33400_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_33500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_33600_PARAMS = { + .alias = "This is a test auth id for Sha1AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA1, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); +class HksRsaSha1WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha1WithRsaPssMt31300 + * @tc.name : HksRsaSha1WithRsaPssMt31300 + * @tc.desc : Test huks sign (512/SHA1withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_31300_PARAMS); } -static const struct HksParam RSA_31500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha1WithRsaPssMt31400 + * @tc.name : HksRsaSha1WithRsaPssMt31400 + * @tc.desc : Test huks sign (512/SHA1withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_31400_PARAMS); +} /** - * @tc.number : HksRsaMtTest31500 - * @tc.name : HksRsaMtTest31500 + * @tc.number : HksRsaSha1WithRsaPssMt31500 + * @tc.name : HksRsaSha1WithRsaPssMt31500 * @tc.desc : Test huks Verify (512/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31500, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31500_PARAMS, sizeof(RSA_31500_PARAMS) / sizeof(RSA_31500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_31500_PARAMS); } -static const struct HksParam RSA_31600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest31600 - * @tc.name : HksRsaMtTest31600 + * @tc.number : HksRsaSha1WithRsaPssMt31600 + * @tc.name : HksRsaSha1WithRsaPssMt31600 * @tc.desc : Test huks Verify (512/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31600, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31600_PARAMS, sizeof(RSA_31600_PARAMS) / sizeof(RSA_31600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_31600_PARAMS); } -static const struct HksParam RSA_31700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest31700 - * @tc.name : HksRsaMtTest31700 + * @tc.number : HksRsaSha1WithRsaPssMt31700 + * @tc.name : HksRsaSha1WithRsaPssMt31700 * @tc.desc : Test huks sign (768/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31700, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31700_PARAMS, sizeof(RSA_31700_PARAMS) / sizeof(RSA_31700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_31700_PARAMS); } -static const struct HksParam RSA_31800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest31800 - * @tc.name : HksRsaMtTest31800 + * @tc.number : HksRsaSha1WithRsaPssMt31800 + * @tc.name : HksRsaSha1WithRsaPssMt31800 * @tc.desc : Test huks sign (768/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31800, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31800_PARAMS, sizeof(RSA_31800_PARAMS) / sizeof(RSA_31800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_31800_PARAMS); } -static const struct HksParam RSA_31900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest31900 - * @tc.name : HksRsaMtTest31900 + * @tc.number : HksRsaSha1WithRsaPssMt31900 + * @tc.name : HksRsaSha1WithRsaPssMt31900 * @tc.desc : Test huks Verify (768/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest31900, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt31900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_31900_PARAMS, sizeof(RSA_31900_PARAMS) / sizeof(RSA_31900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_31900_PARAMS); } -static const struct HksParam RSA_32000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32000 - * @tc.name : HksRsaMtTest32000 + * @tc.number : HksRsaSha1WithRsaPssMt32000 + * @tc.name : HksRsaSha1WithRsaPssMt32000 * @tc.desc : Test huks Verify (768/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32000, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32000_PARAMS, sizeof(RSA_32000_PARAMS) / sizeof(RSA_32000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_32000_PARAMS); } -static const struct HksParam RSA_32100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32100 - * @tc.name : HksRsaMtTest32100 + * @tc.number : HksRsaSha1WithRsaPssMt32100 + * @tc.name : HksRsaSha1WithRsaPssMt32100 * @tc.desc : Test huks sign (1024/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32100, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32100_PARAMS, sizeof(RSA_32100_PARAMS) / sizeof(RSA_32100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_32100_PARAMS); } -static const struct HksParam RSA_32200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32200 - * @tc.name : HksRsaMtTest32200 + * @tc.number : HksRsaSha1WithRsaPssMt32200 + * @tc.name : HksRsaSha1WithRsaPssMt32200 * @tc.desc : Test huks sign (1024/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32200, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32200_PARAMS, sizeof(RSA_32200_PARAMS) / sizeof(RSA_32200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_32200_PARAMS); } -static const struct HksParam RSA_32300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32300 - * @tc.name : HksRsaMtTest32300 + * @tc.number : HksRsaSha1WithRsaPssMt32300 + * @tc.name : HksRsaSha1WithRsaPssMt32300 * @tc.desc : Test huks Verify (1024/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32300, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32300_PARAMS, sizeof(RSA_32300_PARAMS) / sizeof(RSA_32300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_32300_PARAMS); } -static const struct HksParam RSA_32400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32400 - * @tc.name : HksRsaMtTest32400 + * @tc.number : HksRsaSha1WithRsaPssMt32400 + * @tc.name : HksRsaSha1WithRsaPssMt32400 * @tc.desc : Test huks Verify (1024/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32400, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32400_PARAMS, sizeof(RSA_32400_PARAMS) / sizeof(RSA_32400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_32400_PARAMS); } -static const struct HksParam RSA_32500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32500 - * @tc.name : HksRsaMtTest32500 + * @tc.number : HksRsaSha1WithRsaPssMt32500 + * @tc.name : HksRsaSha1WithRsaPssMt32500 * @tc.desc : Test huks sign (2048/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32500, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32500_PARAMS, sizeof(RSA_32500_PARAMS) / sizeof(RSA_32500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_32500_PARAMS); } -static const struct HksParam RSA_32600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32600 - * @tc.name : HksRsaMtTest32600 + * @tc.number : HksRsaSha1WithRsaPssMt32600 + * @tc.name : HksRsaSha1WithRsaPssMt32600 * @tc.desc : Test huks sign (2048/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32600, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32600_PARAMS, sizeof(RSA_32600_PARAMS) / sizeof(RSA_32600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_32600_PARAMS); } -static const struct HksParam RSA_32700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32700 - * @tc.name : HksRsaMtTest32700 + * @tc.number : HksRsaSha1WithRsaPssMt32700 + * @tc.name : HksRsaSha1WithRsaPssMt32700 * @tc.desc : Test huks Verify (2048/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32700, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32700_PARAMS, sizeof(RSA_32700_PARAMS) / sizeof(RSA_32700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_32700_PARAMS); } -static const struct HksParam RSA_32800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32800 - * @tc.name : HksRsaMtTest32800 + * @tc.number : HksRsaSha1WithRsaPssMt32800 + * @tc.name : HksRsaSha1WithRsaPssMt32800 * @tc.desc : Test huks Verify (2048/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32800, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32800_PARAMS, sizeof(RSA_32800_PARAMS) / sizeof(RSA_32800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_32800_PARAMS); } -static const struct HksParam RSA_32900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest32900 - * @tc.name : HksRsaMtTest32900 + * @tc.number : HksRsaSha1WithRsaPssMt32900 + * @tc.name : HksRsaSha1WithRsaPssMt32900 * @tc.desc : Test huks sign (3072/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest32900, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt32900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_32900_PARAMS, sizeof(RSA_32900_PARAMS) / sizeof(RSA_32900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_32900_PARAMS); } -static const struct HksParam RSA_33000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest33000 - * @tc.name : HksRsaMtTest33000 + * @tc.number : HksRsaSha1WithRsaPssMt33000 + * @tc.name : HksRsaSha1WithRsaPssMt33000 * @tc.desc : Test huks sign (3072/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33000, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33000_PARAMS, sizeof(RSA_33000_PARAMS) / sizeof(RSA_33000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_33000_PARAMS); } -static const struct HksParam RSA_33100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest33100 - * @tc.name : HksRsaMtTest33100 + * @tc.number : HksRsaSha1WithRsaPssMt33100 + * @tc.name : HksRsaSha1WithRsaPssMt33100 * @tc.desc : Test huks Verify (3072/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33100, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33100_PARAMS, sizeof(RSA_33100_PARAMS) / sizeof(RSA_33100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_33100_PARAMS); } -static const struct HksParam RSA_33200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest33200 - * @tc.name : HksRsaMtTest33200 + * @tc.number : HksRsaSha1WithRsaPssMt33200 + * @tc.name : HksRsaSha1WithRsaPssMt33200 * @tc.desc : Test huks Verify (3072/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33200, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33200_PARAMS, sizeof(RSA_33200_PARAMS) / sizeof(RSA_33200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_33200_PARAMS); } -static const struct HksParam RSA_33300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest33300 - * @tc.name : HksRsaMtTest33300 + * @tc.number : HksRsaSha1WithRsaPssMt33300 + * @tc.name : HksRsaSha1WithRsaPssMt33300 * @tc.desc : Test huks sign (4096/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33300, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33300_PARAMS, sizeof(RSA_33300_PARAMS) / sizeof(RSA_33300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_33300_PARAMS); } -static const struct HksParam RSA_33400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest33400 - * @tc.name : HksRsaMtTest33400 + * @tc.number : HksRsaSha1WithRsaPssMt33400 + * @tc.name : HksRsaSha1WithRsaPssMt33400 * @tc.desc : Test huks sign (4096/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33400, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33400_PARAMS, sizeof(RSA_33400_PARAMS) / sizeof(RSA_33400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_33400_PARAMS); } -static const struct HksParam RSA_33500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest33500 - * @tc.name : HksRsaMtTest33500 + * @tc.number : HksRsaSha1WithRsaPssMt33500 + * @tc.name : HksRsaSha1WithRsaPssMt33500 * @tc.desc : Test huks Verify (4096/SHA1withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33500, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33500_PARAMS, sizeof(RSA_33500_PARAMS) / sizeof(RSA_33500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_33500_PARAMS); } -static const struct HksParam RSA_33600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest33600 - * @tc.name : HksRsaMtTest33600 + * @tc.number : HksRsaSha1WithRsaPssMt33600 + * @tc.name : HksRsaSha1WithRsaPssMt33600 * @tc.desc : Test huks Verify (4096/SHA1withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaMtTest33600, TestSize.Level1) +HWTEST_F(HksRsaSha1WithRsaPssMt, HksRsaSha1WithRsaPssMt33600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33600_PARAMS, sizeof(RSA_33600_PARAMS) / sizeof(RSA_33600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA1), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_33600_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp index 1aa69450..aab3d3db 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1576 +25,759 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA224"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha224WithRsaMt : public testing::Test {}; -static const struct HksParam RSA_33700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_33700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest33700 - * @tc.name : HksRsaMtTest33700 - * @tc.desc : Test huks sign (512/SHA224withRSA/TEMP) - */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest33700, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33700_PARAMS, sizeof(RSA_33700_PARAMS) / sizeof(RSA_33700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_33800_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_33900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_34000_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_34100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_34200_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_34300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_34400_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_34500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); +const SignServiceCaseParams HKS_RSA_MT_34600_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_34700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_33800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_34800_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest33800 - * @tc.name : HksRsaMtTest33800 - * @tc.desc : Test huks sign (512/SHA224withRSA/PERSISTENT) - */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest33800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_34900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_35000_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_33800_PARAMS, sizeof(RSA_33800_PARAMS) / sizeof(RSA_33800_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_35100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_35200_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_35300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_35400_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_35500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_35600_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_35700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_35800_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_35900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_36000_PARAMS = { + .alias = "This is a test auth id for SHA224", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); +class HksRsaSha224WithRsaMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha224WithRsaMt33700 + * @tc.name : HksRsaSha224WithRsaMt33700 + * @tc.desc : Test huks sign (512/SHA224withRSA/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt33700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_33700_PARAMS); } -static const struct HksParam RSA_33900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha224WithRsaMt33800 + * @tc.name : HksRsaSha224WithRsaMt33800 + * @tc.desc : Test huks sign (512/SHA224withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt33800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_33800_PARAMS); +} /** - * @tc.number : HksRsaMtTest33900 - * @tc.name : HksRsaMtTest33900 + * @tc.number : HksRsaSha224WithRsaMt33900 + * @tc.name : HksRsaSha224WithRsaMt33900 * @tc.desc : Test huks Verify (512/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest33900, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt33900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_33900_PARAMS, sizeof(RSA_33900_PARAMS) / sizeof(RSA_33900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_33900_PARAMS); } -static const struct HksParam RSA_34000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34000 - * @tc.name : HksRsaMtTest34000 + * @tc.number : HksRsaSha224WithRsaMt34000 + * @tc.name : HksRsaSha224WithRsaMt34000 * @tc.desc : Test huks Verify (512/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34000, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34000_PARAMS, sizeof(RSA_34000_PARAMS) / sizeof(RSA_34000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_34000_PARAMS); } -static const struct HksParam RSA_34100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34100 - * @tc.name : HksRsaMtTest34100 + * @tc.number : HksRsaSha224WithRsaMt34100 + * @tc.name : HksRsaSha224WithRsaMt34100 * @tc.desc : Test huks sign (768/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34100, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34100_PARAMS, sizeof(RSA_34100_PARAMS) / sizeof(RSA_34100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_34100_PARAMS); } -static const struct HksParam RSA_34200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34200 - * @tc.name : HksRsaMtTest34200 + * @tc.number : HksRsaSha224WithRsaMt34200 + * @tc.name : HksRsaSha224WithRsaMt34200 * @tc.desc : Test huks sign (768/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34200, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34200_PARAMS, sizeof(RSA_34200_PARAMS) / sizeof(RSA_34200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_34200_PARAMS); } -static const struct HksParam RSA_34300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34300 - * @tc.name : HksRsaMtTest34300 + * @tc.number : HksRsaSha224WithRsaMt34300 + * @tc.name : HksRsaSha224WithRsaMt34300 * @tc.desc : Test huks Verify (768/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34300, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34300_PARAMS, sizeof(RSA_34300_PARAMS) / sizeof(RSA_34300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_34300_PARAMS); } -static const struct HksParam RSA_34400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34400 - * @tc.name : HksRsaMtTest34400 + * @tc.number : HksRsaSha224WithRsaMt34400 + * @tc.name : HksRsaSha224WithRsaMt34400 * @tc.desc : Test huks Verify (768/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34400, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34400_PARAMS, sizeof(RSA_34400_PARAMS) / sizeof(RSA_34400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_34400_PARAMS); } -static const struct HksParam RSA_34500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34500 - * @tc.name : HksRsaMtTest34500 + * @tc.number : HksRsaSha224WithRsaMt34500 + * @tc.name : HksRsaSha224WithRsaMt34500 * @tc.desc : Test huks sign (1024/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34500, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34500_PARAMS, sizeof(RSA_34500_PARAMS) / sizeof(RSA_34500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_34500_PARAMS); } -static const struct HksParam RSA_34600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34600 - * @tc.name : HksRsaMtTest34600 + * @tc.number : HksRsaSha224WithRsaMt34600 + * @tc.name : HksRsaSha224WithRsaMt34600 * @tc.desc : Test huks sign (1024/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34600, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34600_PARAMS, sizeof(RSA_34600_PARAMS) / sizeof(RSA_34600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_34600_PARAMS); } -static const struct HksParam RSA_34700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34700 - * @tc.name : HksRsaMtTest34700 + * @tc.number : HksRsaSha224WithRsaMt34700 + * @tc.name : HksRsaSha224WithRsaMt34700 * @tc.desc : Test huks Verify (1024/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34700, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34700_PARAMS, sizeof(RSA_34700_PARAMS) / sizeof(RSA_34700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_34700_PARAMS); } -static const struct HksParam RSA_34800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34800 - * @tc.name : HksRsaMtTest34800 + * @tc.number : HksRsaSha224WithRsaMt34800 + * @tc.name : HksRsaSha224WithRsaMt34800 * @tc.desc : Test huks Verify (1024/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34800, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34800_PARAMS, sizeof(RSA_34800_PARAMS) / sizeof(RSA_34800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_34800_PARAMS); } -static const struct HksParam RSA_34900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest34900 - * @tc.name : HksRsaMtTest34900 + * @tc.number : HksRsaSha224WithRsaMt34900 + * @tc.name : HksRsaSha224WithRsaMt34900 * @tc.desc : Test huks sign (2048/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest34900, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt34900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_34900_PARAMS, sizeof(RSA_34900_PARAMS) / sizeof(RSA_34900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_34900_PARAMS); } -static const struct HksParam RSA_35000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35000 - * @tc.name : HksRsaMtTest35000 + * @tc.number : HksRsaSha224WithRsaMt35000 + * @tc.name : HksRsaSha224WithRsaMt35000 * @tc.desc : Test huks sign (2048/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35000, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35000_PARAMS, sizeof(RSA_35000_PARAMS) / sizeof(RSA_35000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_35000_PARAMS); } -static const struct HksParam RSA_35100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35100 - * @tc.name : HksRsaMtTest35100 + * @tc.number : HksRsaSha224WithRsaMt35100 + * @tc.name : HksRsaSha224WithRsaMt35100 * @tc.desc : Test huks Verify (2048/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35100, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35100_PARAMS, sizeof(RSA_35100_PARAMS) / sizeof(RSA_35100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_35100_PARAMS); } -static const struct HksParam RSA_35200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35200 - * @tc.name : HksRsaMtTest35200 + * @tc.number : HksRsaSha224WithRsaMt35200 + * @tc.name : HksRsaSha224WithRsaMt35200 * @tc.desc : Test huks Verify (2048/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35200, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35200_PARAMS, sizeof(RSA_35200_PARAMS) / sizeof(RSA_35200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_35200_PARAMS); } -static const struct HksParam RSA_35300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35300 - * @tc.name : HksRsaMtTest35300 + * @tc.number : HksRsaSha224WithRsaMt35300 + * @tc.name : HksRsaSha224WithRsaMt35300 * @tc.desc : Test huks sign (3072/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35300, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35300_PARAMS, sizeof(RSA_35300_PARAMS) / sizeof(RSA_35300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_35300_PARAMS); } -static const struct HksParam RSA_35400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35400 - * @tc.name : HksRsaMtTest35400 + * @tc.number : HksRsaSha224WithRsaMt35400 + * @tc.name : HksRsaSha224WithRsaMt35400 * @tc.desc : Test huks sign (3072/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35400, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35400_PARAMS, sizeof(RSA_35400_PARAMS) / sizeof(RSA_35400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_35400_PARAMS); } -static const struct HksParam RSA_35500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35500 - * @tc.name : HksRsaMtTest35500 + * @tc.number : HksRsaSha224WithRsaMt35500 + * @tc.name : HksRsaSha224WithRsaMt35500 * @tc.desc : Test huks Verify (3072/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35500, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35500_PARAMS, sizeof(RSA_35500_PARAMS) / sizeof(RSA_35500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_35500_PARAMS); } -static const struct HksParam RSA_35600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35600 - * @tc.name : HksRsaMtTest35600 + * @tc.number : HksRsaSha224WithRsaMt35600 + * @tc.name : HksRsaSha224WithRsaMt35600 * @tc.desc : Test huks Verify (3072/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35600, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35600_PARAMS, sizeof(RSA_35600_PARAMS) / sizeof(RSA_35600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_35600_PARAMS); } -static const struct HksParam RSA_35700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35700 - * @tc.name : HksRsaMtTest35700 + * @tc.number : HksRsaSha224WithRsaMt35700 + * @tc.name : HksRsaSha224WithRsaMt35700 * @tc.desc : Test huks sign (4096/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35700, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35700_PARAMS, sizeof(RSA_35700_PARAMS) / sizeof(RSA_35700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_35700_PARAMS); } -static const struct HksParam RSA_35800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35800 - * @tc.name : HksRsaMtTest35800 + * @tc.number : HksRsaSha224WithRsaMt35800 + * @tc.name : HksRsaSha224WithRsaMt35800 * @tc.desc : Test huks sign (4096/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35800, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35800_PARAMS, sizeof(RSA_35800_PARAMS) / sizeof(RSA_35800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_35800_PARAMS); } -static const struct HksParam RSA_35900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest35900 - * @tc.name : HksRsaMtTest35900 + * @tc.number : HksRsaSha224WithRsaMt35900 + * @tc.name : HksRsaSha224WithRsaMt35900 * @tc.desc : Test huks Verify (4096/SHA224withRSA/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest35900, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt35900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_35900_PARAMS, sizeof(RSA_35900_PARAMS) / sizeof(RSA_35900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_35900_PARAMS); } -static const struct HksParam RSA_36000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest36000 - * @tc.name : HksRsaMtTest36000 + * @tc.number : HksRsaSha224WithRsaMt36000 + * @tc.name : HksRsaSha224WithRsaMt36000 * @tc.desc : Test huks Verify (4096/SHA224withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaMt, HksRsaMtTest36000, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaMt, HksRsaSha224WithRsaMt36000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36000_PARAMS, sizeof(RSA_36000_PARAMS) / sizeof(RSA_36000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_36000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp index ecc66d20..457fda34 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha224_with_rsa_pss_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1576 +25,759 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha224AndPss"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha224WithRsaPssMt : public testing::Test {}; -static const struct HksParam RSA_36100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_36100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest36100 - * @tc.name : HksRsaMtTest36100 - * @tc.desc : Test huks sign (512/SHA224withRSA/PSS/TEMP) - */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36100_PARAMS, sizeof(RSA_36100_PARAMS) / sizeof(RSA_36100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_36200_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_36300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_36400_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_36500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_36600_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_36700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_36800_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_36900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); +const SignServiceCaseParams HKS_RSA_MT_37000_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_37100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_36200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_37200_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest36200 - * @tc.name : HksRsaMtTest36200 - * @tc.desc : Test huks sign (512/SHA224withRSA/PSS/PERSISTENT) - */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_37300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_37400_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_36200_PARAMS, sizeof(RSA_36200_PARAMS) / sizeof(RSA_36200_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_37500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_37600_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_37700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_37800_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_37900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_38000_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_38100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_38200_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_38300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_38400_PARAMS = { + .alias = "This is a test auth id for Sha224AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA224, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); +class HksRsaSha224WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha224WithRsaPssMt36100 + * @tc.name : HksRsaSha224WithRsaPssMt36100 + * @tc.desc : Test huks sign (512/SHA224withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_36100_PARAMS); } -static const struct HksParam RSA_36300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha224WithRsaPssMt36200 + * @tc.name : HksRsaSha224WithRsaPssMt36200 + * @tc.desc : Test huks sign (512/SHA224withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_36200_PARAMS); +} /** - * @tc.number : HksRsaMtTest36300 - * @tc.name : HksRsaMtTest36300 + * @tc.number : HksRsaSha224WithRsaPssMt36300 + * @tc.name : HksRsaSha224WithRsaPssMt36300 * @tc.desc : Test huks Verify (512/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36300, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36300_PARAMS, sizeof(RSA_36300_PARAMS) / sizeof(RSA_36300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_36300_PARAMS); } -static const struct HksParam RSA_36400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest36400 - * @tc.name : HksRsaMtTest36400 + * @tc.number : HksRsaSha224WithRsaPssMt36400 + * @tc.name : HksRsaSha224WithRsaPssMt36400 * @tc.desc : Test huks Verify (512/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36400, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36400_PARAMS, sizeof(RSA_36400_PARAMS) / sizeof(RSA_36400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_36400_PARAMS); } -static const struct HksParam RSA_36500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest36500 - * @tc.name : HksRsaMtTest36500 + * @tc.number : HksRsaSha224WithRsaPssMt36500 + * @tc.name : HksRsaSha224WithRsaPssMt36500 * @tc.desc : Test huks sign (768/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36500, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36500_PARAMS, sizeof(RSA_36500_PARAMS) / sizeof(RSA_36500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_36500_PARAMS); } -static const struct HksParam RSA_36600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest36600 - * @tc.name : HksRsaMtTest36600 + * @tc.number : HksRsaSha224WithRsaPssMt36600 + * @tc.name : HksRsaSha224WithRsaPssMt36600 * @tc.desc : Test huks sign (768/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36600, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36600_PARAMS, sizeof(RSA_36600_PARAMS) / sizeof(RSA_36600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_36600_PARAMS); } -static const struct HksParam RSA_36700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest36700 - * @tc.name : HksRsaMtTest36700 + * @tc.number : HksRsaSha224WithRsaPssMt36700 + * @tc.name : HksRsaSha224WithRsaPssMt36700 * @tc.desc : Test huks Verify (768/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36700, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36700_PARAMS, sizeof(RSA_36700_PARAMS) / sizeof(RSA_36700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_36700_PARAMS); } -static const struct HksParam RSA_36800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest36800 - * @tc.name : HksRsaMtTest36800 + * @tc.number : HksRsaSha224WithRsaPssMt36800 + * @tc.name : HksRsaSha224WithRsaPssMt36800 * @tc.desc : Test huks Verify (768/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36800, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36800_PARAMS, sizeof(RSA_36800_PARAMS) / sizeof(RSA_36800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_36800_PARAMS); } -static const struct HksParam RSA_36900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest36900 - * @tc.name : HksRsaMtTest36900 + * @tc.number : HksRsaSha224WithRsaPssMt36900 + * @tc.name : HksRsaSha224WithRsaPssMt36900 * @tc.desc : Test huks sign (1024/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest36900, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt36900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_36900_PARAMS, sizeof(RSA_36900_PARAMS) / sizeof(RSA_36900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_36900_PARAMS); } -static const struct HksParam RSA_37000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37000 - * @tc.name : HksRsaMtTest37000 + * @tc.number : HksRsaSha224WithRsaPssMt37000 + * @tc.name : HksRsaSha224WithRsaPssMt37000 * @tc.desc : Test huks sign (1024/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37000, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37000_PARAMS, sizeof(RSA_37000_PARAMS) / sizeof(RSA_37000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_37000_PARAMS); } -static const struct HksParam RSA_37100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37100 - * @tc.name : HksRsaMtTest37100 + * @tc.number : HksRsaSha224WithRsaPssMt37100 + * @tc.name : HksRsaSha224WithRsaPssMt37100 * @tc.desc : Test huks Verify (1024/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37100, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37100_PARAMS, sizeof(RSA_37100_PARAMS) / sizeof(RSA_37100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_37100_PARAMS); } -static const struct HksParam RSA_37200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37200 - * @tc.name : HksRsaMtTest37200 + * @tc.number : HksRsaSha224WithRsaPssMt37200 + * @tc.name : HksRsaSha224WithRsaPssMt37200 * @tc.desc : Test huks Verify (1024/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37200, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37200_PARAMS, sizeof(RSA_37200_PARAMS) / sizeof(RSA_37200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_37200_PARAMS); } -static const struct HksParam RSA_37300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37300 - * @tc.name : HksRsaMtTest37300 + * @tc.number : HksRsaSha224WithRsaPssMt37300 + * @tc.name : HksRsaSha224WithRsaPssMt37300 * @tc.desc : Test huks sign (2048/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37300, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37300_PARAMS, sizeof(RSA_37300_PARAMS) / sizeof(RSA_37300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_37300_PARAMS); } -static const struct HksParam RSA_37400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37400 - * @tc.name : HksRsaMtTest37400 + * @tc.number : HksRsaSha224WithRsaPssMt37400 + * @tc.name : HksRsaSha224WithRsaPssMt37400 * @tc.desc : Test huks sign (2048/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37400, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37400_PARAMS, sizeof(RSA_37400_PARAMS) / sizeof(RSA_37400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_37400_PARAMS); } -static const struct HksParam RSA_37500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37500 - * @tc.name : HksRsaMtTest37500 + * @tc.number : HksRsaSha224WithRsaPssMt37500 + * @tc.name : HksRsaSha224WithRsaPssMt37500 * @tc.desc : Test huks Verify (2048/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37500, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37500_PARAMS, sizeof(RSA_37500_PARAMS) / sizeof(RSA_37500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_37500_PARAMS); } -static const struct HksParam RSA_37600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37600 - * @tc.name : HksRsaMtTest37600 + * @tc.number : HksRsaSha224WithRsaPssMt37600 + * @tc.name : HksRsaSha224WithRsaPssMt37600 * @tc.desc : Test huks Verify (2048/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37600, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37600_PARAMS, sizeof(RSA_37600_PARAMS) / sizeof(RSA_37600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_37600_PARAMS); } -static const struct HksParam RSA_37700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37700 - * @tc.name : HksRsaMtTest37700 + * @tc.number : HksRsaSha224WithRsaPssMt37700 + * @tc.name : HksRsaSha224WithRsaPssMt37700 * @tc.desc : Test huks sign (3072/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37700, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37700_PARAMS, sizeof(RSA_37700_PARAMS) / sizeof(RSA_37700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_37700_PARAMS); } -static const struct HksParam RSA_37800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37800 - * @tc.name : HksRsaMtTest37800 + * @tc.number : HksRsaSha224WithRsaPssMt37800 + * @tc.name : HksRsaSha224WithRsaPssMt37800 * @tc.desc : Test huks sign (3072/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37800, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37800_PARAMS, sizeof(RSA_37800_PARAMS) / sizeof(RSA_37800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_37800_PARAMS); } -static const struct HksParam RSA_37900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest37900 - * @tc.name : HksRsaMtTest37900 + * @tc.number : HksRsaSha224WithRsaPssMt37900 + * @tc.name : HksRsaSha224WithRsaPssMt37900 * @tc.desc : Test huks Verify (3072/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest37900, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt37900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_37900_PARAMS, sizeof(RSA_37900_PARAMS) / sizeof(RSA_37900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_37900_PARAMS); } -static const struct HksParam RSA_38000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest38000 - * @tc.name : HksRsaMtTest38000 + * @tc.number : HksRsaSha224WithRsaPssMt38000 + * @tc.name : HksRsaSha224WithRsaPssMt38000 * @tc.desc : Test huks Verify (3072/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38000, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38000_PARAMS, sizeof(RSA_38000_PARAMS) / sizeof(RSA_38000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_38000_PARAMS); } -static const struct HksParam RSA_38100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest38100 - * @tc.name : HksRsaMtTest38100 + * @tc.number : HksRsaSha224WithRsaPssMt38100 + * @tc.name : HksRsaSha224WithRsaPssMt38100 * @tc.desc : Test huks sign (4096/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38100, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38100_PARAMS, sizeof(RSA_38100_PARAMS) / sizeof(RSA_38100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_38100_PARAMS); } -static const struct HksParam RSA_38200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest38200 - * @tc.name : HksRsaMtTest38200 + * @tc.number : HksRsaSha224WithRsaPssMt38200 + * @tc.name : HksRsaSha224WithRsaPssMt38200 * @tc.desc : Test huks sign (4096/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38200, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38200_PARAMS, sizeof(RSA_38200_PARAMS) / sizeof(RSA_38200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_38200_PARAMS); } -static const struct HksParam RSA_38300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest38300 - * @tc.name : HksRsaMtTest38300 + * @tc.number : HksRsaSha224WithRsaPssMt38300 + * @tc.name : HksRsaSha224WithRsaPssMt38300 * @tc.desc : Test huks Verify (4096/SHA224withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38300, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38300_PARAMS, sizeof(RSA_38300_PARAMS) / sizeof(RSA_38300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_38300_PARAMS); } -static const struct HksParam RSA_38400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest38400 - * @tc.name : HksRsaMtTest38400 + * @tc.number : HksRsaSha224WithRsaPssMt38400 + * @tc.name : HksRsaSha224WithRsaPssMt38400 * @tc.desc : Test huks Verify (4096/SHA224withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaMtTest38400, TestSize.Level1) +HWTEST_F(HksRsaSha224WithRsaPssMt, HksRsaSha224WithRsaPssMt38400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38400_PARAMS, sizeof(RSA_38400_PARAMS) / sizeof(RSA_38400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA224), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_38400_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp index 16887d62..bda9fc25 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1576 +25,759 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA256"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha256WithRsaMt : public testing::Test {}; -static const struct HksParam RSA_38500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_38500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest38500 - * @tc.name : HksRsaMtTest38500 - * @tc.desc : Test huks sign (512/SHA256withRSA/TEMP) - */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38500, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38500_PARAMS, sizeof(RSA_38500_PARAMS) / sizeof(RSA_38500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_38600_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_38700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_38800_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_38900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_39000_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_39100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_39200_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_39300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); +const SignServiceCaseParams HKS_RSA_MT_39400_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_39500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_38600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_39600_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest38600 - * @tc.name : HksRsaMtTest38600 - * @tc.desc : Test huks sign (512/SHA256withRSA/PERSISTENT) - */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_39700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_39800_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_38600_PARAMS, sizeof(RSA_38600_PARAMS) / sizeof(RSA_38600_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_39900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_40000_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_40100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_40200_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_40300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_40400_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_40500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_40600_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_40700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_40800_PARAMS = { + .alias = "This is a test auth id for SHA256", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); +class HksRsaSha256WithRsaMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha256WithRsaMt38500 + * @tc.name : HksRsaSha256WithRsaMt38500 + * @tc.desc : Test huks sign (512/SHA256withRSA/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_38500_PARAMS); } -static const struct HksParam RSA_38700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha256WithRsaMt38600 + * @tc.name : HksRsaSha256WithRsaMt38600 + * @tc.desc : Test huks sign (512/SHA256withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_38600_PARAMS); +} /** - * @tc.number : HksRsaMtTest38700 - * @tc.name : HksRsaMtTest38700 + * @tc.number : HksRsaSha256WithRsaMt38700 + * @tc.name : HksRsaSha256WithRsaMt38700 * @tc.desc : Test huks Verify (512/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38700, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38700_PARAMS, sizeof(RSA_38700_PARAMS) / sizeof(RSA_38700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_38700_PARAMS); } -static const struct HksParam RSA_38800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest38800 - * @tc.name : HksRsaMtTest38800 + * @tc.number : HksRsaSha256WithRsaMt38800 + * @tc.name : HksRsaSha256WithRsaMt38800 * @tc.desc : Test huks Verify (512/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38800, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38800_PARAMS, sizeof(RSA_38800_PARAMS) / sizeof(RSA_38800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_38800_PARAMS); } -static const struct HksParam RSA_38900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest38900 - * @tc.name : HksRsaMtTest38900 + * @tc.number : HksRsaSha256WithRsaMt38900 + * @tc.name : HksRsaSha256WithRsaMt38900 * @tc.desc : Test huks sign (768/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest38900, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt38900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_38900_PARAMS, sizeof(RSA_38900_PARAMS) / sizeof(RSA_38900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_38900_PARAMS); } -static const struct HksParam RSA_39000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39000 - * @tc.name : HksRsaMtTest39000 + * @tc.number : HksRsaSha256WithRsaMt39000 + * @tc.name : HksRsaSha256WithRsaMt39000 * @tc.desc : Test huks sign (768/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39000, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39000_PARAMS, sizeof(RSA_39000_PARAMS) / sizeof(RSA_39000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_39000_PARAMS); } -static const struct HksParam RSA_39100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39100 - * @tc.name : HksRsaMtTest39100 + * @tc.number : HksRsaSha256WithRsaMt39100 + * @tc.name : HksRsaSha256WithRsaMt39100 * @tc.desc : Test huks Verify (768/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39100, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39100_PARAMS, sizeof(RSA_39100_PARAMS) / sizeof(RSA_39100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_39100_PARAMS); } -static const struct HksParam RSA_39200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39200 - * @tc.name : HksRsaMtTest39200 + * @tc.number : HksRsaSha256WithRsaMt39200 + * @tc.name : HksRsaSha256WithRsaMt39200 * @tc.desc : Test huks Verify (768/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39200, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39200_PARAMS, sizeof(RSA_39200_PARAMS) / sizeof(RSA_39200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_39200_PARAMS); } -static const struct HksParam RSA_39300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39300 - * @tc.name : HksRsaMtTest39300 + * @tc.number : HksRsaSha256WithRsaMt39300 + * @tc.name : HksRsaSha256WithRsaMt39300 * @tc.desc : Test huks sign (1024/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39300, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39300_PARAMS, sizeof(RSA_39300_PARAMS) / sizeof(RSA_39300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_39300_PARAMS); } -static const struct HksParam RSA_39400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39400 - * @tc.name : HksRsaMtTest39400 + * @tc.number : HksRsaSha256WithRsaMt39400 + * @tc.name : HksRsaSha256WithRsaMt39400 * @tc.desc : Test huks sign (1024/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39400, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39400_PARAMS, sizeof(RSA_39400_PARAMS) / sizeof(RSA_39400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_39400_PARAMS); } -static const struct HksParam RSA_39500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39500 - * @tc.name : HksRsaMtTest39500 + * @tc.number : HksRsaSha256WithRsaMt39500 + * @tc.name : HksRsaSha256WithRsaMt39500 * @tc.desc : Test huks Verify (1024/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39500, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39500_PARAMS, sizeof(RSA_39500_PARAMS) / sizeof(RSA_39500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_39500_PARAMS); } -static const struct HksParam RSA_39600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39600 - * @tc.name : HksRsaMtTest39600 + * @tc.number : HksRsaSha256WithRsaMt39600 + * @tc.name : HksRsaSha256WithRsaMt39600 * @tc.desc : Test huks Verify (1024/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39600, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39600_PARAMS, sizeof(RSA_39600_PARAMS) / sizeof(RSA_39600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_39600_PARAMS); } -static const struct HksParam RSA_39700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39700 - * @tc.name : HksRsaMtTest39700 + * @tc.number : HksRsaSha256WithRsaMt39700 + * @tc.name : HksRsaSha256WithRsaMt39700 * @tc.desc : Test huks sign (2048/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39700, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39700_PARAMS, sizeof(RSA_39700_PARAMS) / sizeof(RSA_39700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_39700_PARAMS); } -static const struct HksParam RSA_39800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39800 - * @tc.name : HksRsaMtTest39800 + * @tc.number : HksRsaSha256WithRsaMt39800 + * @tc.name : HksRsaSha256WithRsaMt39800 * @tc.desc : Test huks sign (2048/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39800, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39800_PARAMS, sizeof(RSA_39800_PARAMS) / sizeof(RSA_39800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_39800_PARAMS); } -static const struct HksParam RSA_39900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest39900 - * @tc.name : HksRsaMtTest39900 + * @tc.number : HksRsaSha256WithRsaMt39900 + * @tc.name : HksRsaSha256WithRsaMt39900 * @tc.desc : Test huks Verify (2048/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest39900, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt39900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_39900_PARAMS, sizeof(RSA_39900_PARAMS) / sizeof(RSA_39900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_39900_PARAMS); } -static const struct HksParam RSA_40000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40000 - * @tc.name : HksRsaMtTest40000 + * @tc.number : HksRsaSha256WithRsaMt40000 + * @tc.name : HksRsaSha256WithRsaMt40000 * @tc.desc : Test huks Verify (2048/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40000, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40000_PARAMS, sizeof(RSA_40000_PARAMS) / sizeof(RSA_40000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_40000_PARAMS); } -static const struct HksParam RSA_40100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40100 - * @tc.name : HksRsaMtTest40100 + * @tc.number : HksRsaSha256WithRsaMt40100 + * @tc.name : HksRsaSha256WithRsaMt40100 * @tc.desc : Test huks sign (3072/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40100, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40100_PARAMS, sizeof(RSA_40100_PARAMS) / sizeof(RSA_40100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_40100_PARAMS); } -static const struct HksParam RSA_40200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40200 - * @tc.name : HksRsaMtTest40200 + * @tc.number : HksRsaSha256WithRsaMt40200 + * @tc.name : HksRsaSha256WithRsaMt40200 * @tc.desc : Test huks sign (3072/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40200, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40200_PARAMS, sizeof(RSA_40200_PARAMS) / sizeof(RSA_40200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_40200_PARAMS); } -static const struct HksParam RSA_40300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40300 - * @tc.name : HksRsaMtTest40300 + * @tc.number : HksRsaSha256WithRsaMt40300 + * @tc.name : HksRsaSha256WithRsaMt40300 * @tc.desc : Test huks Verify (3072/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40300, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40300_PARAMS, sizeof(RSA_40300_PARAMS) / sizeof(RSA_40300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_40300_PARAMS); } -static const struct HksParam RSA_40400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40400 - * @tc.name : HksRsaMtTest40400 + * @tc.number : HksRsaSha256WithRsaMt40400 + * @tc.name : HksRsaSha256WithRsaMt40400 * @tc.desc : Test huks Verify (3072/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40400, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40400_PARAMS, sizeof(RSA_40400_PARAMS) / sizeof(RSA_40400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_40400_PARAMS); } -static const struct HksParam RSA_40500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40500 - * @tc.name : HksRsaMtTest40500 + * @tc.number : HksRsaSha256WithRsaMt40500 + * @tc.name : HksRsaSha256WithRsaMt40500 * @tc.desc : Test huks sign (4096/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40500, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40500_PARAMS, sizeof(RSA_40500_PARAMS) / sizeof(RSA_40500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_40500_PARAMS); } -static const struct HksParam RSA_40600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40600 - * @tc.name : HksRsaMtTest40600 + * @tc.number : HksRsaSha256WithRsaMt40600 + * @tc.name : HksRsaSha256WithRsaMt40600 * @tc.desc : Test huks sign (4096/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40600, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40600_PARAMS, sizeof(RSA_40600_PARAMS) / sizeof(RSA_40600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_40600_PARAMS); } -static const struct HksParam RSA_40700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40700 - * @tc.name : HksRsaMtTest40700 + * @tc.number : HksRsaSha256WithRsaMt40700 + * @tc.name : HksRsaSha256WithRsaMt40700 * @tc.desc : Test huks Verify (4096/SHA256withRSA/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40700, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40700_PARAMS, sizeof(RSA_40700_PARAMS) / sizeof(RSA_40700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_40700_PARAMS); } -static const struct HksParam RSA_40800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest40800 - * @tc.name : HksRsaMtTest40800 + * @tc.number : HksRsaSha256WithRsaMt40800 + * @tc.name : HksRsaSha256WithRsaMt40800 * @tc.desc : Test huks Verify (4096/SHA256withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaMt, HksRsaMtTest40800, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaMt, HksRsaSha256WithRsaMt40800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40800_PARAMS, sizeof(RSA_40800_PARAMS) / sizeof(RSA_40800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_40800_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp index 52460a0c..57d546e8 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha256_with_rsa_pss_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1576 +25,759 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha256AndPss"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha256WithRsaPssMt : public testing::Test {}; -static const struct HksParam RSA_40900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_40900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest40900 - * @tc.name : HksRsaMtTest40900 - * @tc.desc : Test huks sign (512/SHA256withRSA/PSS/TEMP) - */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest40900, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_40900_PARAMS, sizeof(RSA_40900_PARAMS) / sizeof(RSA_40900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_41000_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_41100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_41200_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_41300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_41400_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_41500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_41600_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_41700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); +const SignServiceCaseParams HKS_RSA_MT_41800_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_41900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_41000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_42000_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest41000 - * @tc.name : HksRsaMtTest41000 - * @tc.desc : Test huks sign (512/SHA256withRSA/PSS/PERSISTENT) - */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41000, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_42100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_42200_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_41000_PARAMS, sizeof(RSA_41000_PARAMS) / sizeof(RSA_41000_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_42300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_42400_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_42500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_42600_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_42700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_42800_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_42900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_43000_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_43100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_43200_PARAMS = { + .alias = "This is a test auth id for Sha256AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA256, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); +class HksRsaSha256WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha256WithRsaPssMt40900 + * @tc.name : HksRsaSha256WithRsaPssMt40900 + * @tc.desc : Test huks sign (512/SHA256withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt40900, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_40900_PARAMS); } -static const struct HksParam RSA_41100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha256WithRsaPssMt41000 + * @tc.name : HksRsaSha256WithRsaPssMt41000 + * @tc.desc : Test huks sign (512/SHA256withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41000, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_41000_PARAMS); +} /** - * @tc.number : HksRsaMtTest41100 - * @tc.name : HksRsaMtTest41100 + * @tc.number : HksRsaSha256WithRsaPssMt41100 + * @tc.name : HksRsaSha256WithRsaPssMt41100 * @tc.desc : Test huks Verify (512/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41100, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41100_PARAMS, sizeof(RSA_41100_PARAMS) / sizeof(RSA_41100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_41100_PARAMS); } -static const struct HksParam RSA_41200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest41200 - * @tc.name : HksRsaMtTest41200 + * @tc.number : HksRsaSha256WithRsaPssMt41200 + * @tc.name : HksRsaSha256WithRsaPssMt41200 * @tc.desc : Test huks Verify (512/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41200, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41200_PARAMS, sizeof(RSA_41200_PARAMS) / sizeof(RSA_41200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_41200_PARAMS); } -static const struct HksParam RSA_41300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest41300 - * @tc.name : HksRsaMtTest41300 + * @tc.number : HksRsaSha256WithRsaPssMt41300 + * @tc.name : HksRsaSha256WithRsaPssMt41300 * @tc.desc : Test huks sign (768/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41300, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41300_PARAMS, sizeof(RSA_41300_PARAMS) / sizeof(RSA_41300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_41300_PARAMS); } -static const struct HksParam RSA_41400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest41400 - * @tc.name : HksRsaMtTest41400 + * @tc.number : HksRsaSha256WithRsaPssMt41400 + * @tc.name : HksRsaSha256WithRsaPssMt41400 * @tc.desc : Test huks sign (768/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41400, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41400_PARAMS, sizeof(RSA_41400_PARAMS) / sizeof(RSA_41400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_41400_PARAMS); } -static const struct HksParam RSA_41500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest41500 - * @tc.name : HksRsaMtTest41500 + * @tc.number : HksRsaSha256WithRsaPssMt41500 + * @tc.name : HksRsaSha256WithRsaPssMt41500 * @tc.desc : Test huks Verify (768/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41500, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41500_PARAMS, sizeof(RSA_41500_PARAMS) / sizeof(RSA_41500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_41500_PARAMS); } -static const struct HksParam RSA_41600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest41600 - * @tc.name : HksRsaMtTest41600 + * @tc.number : HksRsaSha256WithRsaPssMt41600 + * @tc.name : HksRsaSha256WithRsaPssMt41600 * @tc.desc : Test huks Verify (768/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41600, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41600_PARAMS, sizeof(RSA_41600_PARAMS) / sizeof(RSA_41600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_41600_PARAMS); } -static const struct HksParam RSA_41700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest41700 - * @tc.name : HksRsaMtTest41700 + * @tc.number : HksRsaSha256WithRsaPssMt41700 + * @tc.name : HksRsaSha256WithRsaPssMt41700 * @tc.desc : Test huks sign (1024/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41700, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41700_PARAMS, sizeof(RSA_41700_PARAMS) / sizeof(RSA_41700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_41700_PARAMS); } -static const struct HksParam RSA_41800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest41800 - * @tc.name : HksRsaMtTest41800 + * @tc.number : HksRsaSha256WithRsaPssMt41800 + * @tc.name : HksRsaSha256WithRsaPssMt41800 * @tc.desc : Test huks sign (1024/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41800, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41800_PARAMS, sizeof(RSA_41800_PARAMS) / sizeof(RSA_41800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_41800_PARAMS); } -static const struct HksParam RSA_41900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest41900 - * @tc.name : HksRsaMtTest41900 + * @tc.number : HksRsaSha256WithRsaPssMt41900 + * @tc.name : HksRsaSha256WithRsaPssMt41900 * @tc.desc : Test huks Verify (1024/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest41900, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt41900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_41900_PARAMS, sizeof(RSA_41900_PARAMS) / sizeof(RSA_41900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_41900_PARAMS); } -static const struct HksParam RSA_42000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42000 - * @tc.name : HksRsaMtTest42000 + * @tc.number : HksRsaSha256WithRsaPssMt42000 + * @tc.name : HksRsaSha256WithRsaPssMt42000 * @tc.desc : Test huks Verify (1024/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42000, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42000_PARAMS, sizeof(RSA_42000_PARAMS) / sizeof(RSA_42000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_42000_PARAMS); } -static const struct HksParam RSA_42100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42100 - * @tc.name : HksRsaMtTest42100 + * @tc.number : HksRsaSha256WithRsaPssMt42100 + * @tc.name : HksRsaSha256WithRsaPssMt42100 * @tc.desc : Test huks sign (2048/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42100, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42100_PARAMS, sizeof(RSA_42100_PARAMS) / sizeof(RSA_42100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_42100_PARAMS); } -static const struct HksParam RSA_42200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42200 - * @tc.name : HksRsaMtTest42200 + * @tc.number : HksRsaSha256WithRsaPssMt42200 + * @tc.name : HksRsaSha256WithRsaPssMt42200 * @tc.desc : Test huks sign (2048/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42200, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42200_PARAMS, sizeof(RSA_42200_PARAMS) / sizeof(RSA_42200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_42200_PARAMS); } -static const struct HksParam RSA_42300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42300 - * @tc.name : HksRsaMtTest42300 + * @tc.number : HksRsaSha256WithRsaPssMt42300 + * @tc.name : HksRsaSha256WithRsaPssMt42300 * @tc.desc : Test huks Verify (2048/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42300, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42300_PARAMS, sizeof(RSA_42300_PARAMS) / sizeof(RSA_42300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_42300_PARAMS); } -static const struct HksParam RSA_42400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42400 - * @tc.name : HksRsaMtTest42400 + * @tc.number : HksRsaSha256WithRsaPssMt42400 + * @tc.name : HksRsaSha256WithRsaPssMt42400 * @tc.desc : Test huks Verify (2048/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42400, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42400_PARAMS, sizeof(RSA_42400_PARAMS) / sizeof(RSA_42400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_42400_PARAMS); } -static const struct HksParam RSA_42500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42500 - * @tc.name : HksRsaMtTest42500 + * @tc.number : HksRsaSha256WithRsaPssMt42500 + * @tc.name : HksRsaSha256WithRsaPssMt42500 * @tc.desc : Test huks sign (3072/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42500, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42500_PARAMS, sizeof(RSA_42500_PARAMS) / sizeof(RSA_42500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_42500_PARAMS); } -static const struct HksParam RSA_42600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42600 - * @tc.name : HksRsaMtTest42600 + * @tc.number : HksRsaSha256WithRsaPssMt42600 + * @tc.name : HksRsaSha256WithRsaPssMt42600 * @tc.desc : Test huks sign (3072/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42600, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42600_PARAMS, sizeof(RSA_42600_PARAMS) / sizeof(RSA_42600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_42600_PARAMS); } -static const struct HksParam RSA_42700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42700 - * @tc.name : HksRsaMtTest42700 + * @tc.number : HksRsaSha256WithRsaPssMt42700 + * @tc.name : HksRsaSha256WithRsaPssMt42700 * @tc.desc : Test huks Verify (3072/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42700, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42700_PARAMS, sizeof(RSA_42700_PARAMS) / sizeof(RSA_42700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_42700_PARAMS); } -static const struct HksParam RSA_42800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42800 - * @tc.name : HksRsaMtTest42800 + * @tc.number : HksRsaSha256WithRsaPssMt42800 + * @tc.name : HksRsaSha256WithRsaPssMt42800 * @tc.desc : Test huks Verify (3072/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42800, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42800_PARAMS, sizeof(RSA_42800_PARAMS) / sizeof(RSA_42800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_42800_PARAMS); } -static const struct HksParam RSA_42900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest42900 - * @tc.name : HksRsaMtTest42900 + * @tc.number : HksRsaSha256WithRsaPssMt42900 + * @tc.name : HksRsaSha256WithRsaPssMt42900 * @tc.desc : Test huks sign (4096/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest42900, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt42900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_42900_PARAMS, sizeof(RSA_42900_PARAMS) / sizeof(RSA_42900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_42900_PARAMS); } -static const struct HksParam RSA_43000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest43000 - * @tc.name : HksRsaMtTest43000 + * @tc.number : HksRsaSha256WithRsaPssMt43000 + * @tc.name : HksRsaSha256WithRsaPssMt43000 * @tc.desc : Test huks sign (4096/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest43000, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt43000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43000_PARAMS, sizeof(RSA_43000_PARAMS) / sizeof(RSA_43000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_43000_PARAMS); } -static const struct HksParam RSA_43100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest43100 - * @tc.name : HksRsaMtTest43100 + * @tc.number : HksRsaSha256WithRsaPssMt43100 + * @tc.name : HksRsaSha256WithRsaPssMt43100 * @tc.desc : Test huks Verify (4096/SHA256withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest43100, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt43100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43100_PARAMS, sizeof(RSA_43100_PARAMS) / sizeof(RSA_43100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_43100_PARAMS); } -static const struct HksParam RSA_43200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest43200 - * @tc.name : HksRsaMtTest43200 + * @tc.number : HksRsaSha256WithRsaPssMt43200 + * @tc.name : HksRsaSha256WithRsaPssMt43200 * @tc.desc : Test huks Verify (4096/SHA256withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaMtTest43200, TestSize.Level1) +HWTEST_F(HksRsaSha256WithRsaPssMt, HksRsaSha256WithRsaPssMt43200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43200_PARAMS, sizeof(RSA_43200_PARAMS) / sizeof(RSA_43200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA256), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_43200_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp index 7a8455df..997fa0c9 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1564 +25,767 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA384"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha384WithRsaMt : public testing::Test {}; -static const struct HksParam RSA_43300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_43300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif }; -/** - * @tc.number : HksRsaMtTest43300 - * @tc.name : HksRsaMtTest43300 - * @tc.desc : Test huks sign (512/SHA384withRSA/TEMP) - */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43300, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43300_PARAMS, sizeof(RSA_43300_PARAMS) / sizeof(RSA_43300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_43400_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_43500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_43600_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_43700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_43800_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_43900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const VerifyServiceCaseParams HKS_RSA_MT_44000_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignLocalCaseParams HKS_RSA_MT_44100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const SignServiceCaseParams HKS_RSA_MT_44200_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); -#endif +const VerifyLocalCaseParams HKS_RSA_MT_44300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyServiceCaseParams HKS_RSA_MT_44400_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_43400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_44500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest43400 - * @tc.name : HksRsaMtTest43400 - * @tc.desc : Test huks sign (512/SHA384withRSA/PERSISTENT) - */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43400, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignServiceCaseParams HKS_RSA_MT_44600_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const VerifyLocalCaseParams HKS_RSA_MT_44700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_43400_PARAMS, sizeof(RSA_43400_PARAMS) / sizeof(RSA_43400_PARAMS[0])), - HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_44800_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_44900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_45000_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_45100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyServiceCaseParams HKS_RSA_MT_45200_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const SignLocalCaseParams HKS_RSA_MT_45300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_45400_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_45500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_45600_PARAMS = { + .alias = "This is a test auth id for SHA384", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace -#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); -#endif +class HksRsaSha384WithRsaMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha384WithRsaMt43300 + * @tc.name : HksRsaSha384WithRsaMt43300 + * @tc.desc : Test huks sign (512/SHA384withRSA/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43300, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_43300_PARAMS); } -static const struct HksParam RSA_43500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha384WithRsaMt43400 + * @tc.name : HksRsaSha384WithRsaMt43400 + * @tc.desc : Test huks sign (512/SHA384withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43400, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_43400_PARAMS); +} /** - * @tc.number : HksRsaMtTest43500 - * @tc.name : HksRsaMtTest43500 + * @tc.number : HksRsaSha384WithRsaMt43500 + * @tc.name : HksRsaSha384WithRsaMt43500 * @tc.desc : Test huks Verify (512/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43500, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43500_PARAMS, sizeof(RSA_43500_PARAMS) / sizeof(RSA_43500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); - - free(paramSetOut); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_43500_PARAMS); } -static const struct HksParam RSA_43600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest43600 - * @tc.name : HksRsaMtTest43600 + * @tc.number : HksRsaSha384WithRsaMt43600 + * @tc.name : HksRsaSha384WithRsaMt43600 * @tc.desc : Test huks Verify (512/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43600, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43600, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43600_PARAMS, sizeof(RSA_43600_PARAMS) / sizeof(RSA_43600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ( - OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), RSA_FAILED); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_43600_PARAMS); } -static const struct HksParam RSA_43700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest43700 - * @tc.name : HksRsaMtTest43700 + * @tc.number : HksRsaSha384WithRsaMt43700 + * @tc.name : HksRsaSha384WithRsaMt43700 * @tc.desc : Test huks sign (768/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43700, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43700_PARAMS, sizeof(RSA_43700_PARAMS) / sizeof(RSA_43700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_43700_PARAMS); } -static const struct HksParam RSA_43800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest43800 - * @tc.name : HksRsaMtTest43800 + * @tc.number : HksRsaSha384WithRsaMt43800 + * @tc.name : HksRsaSha384WithRsaMt43800 * @tc.desc : Test huks sign (768/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43800, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43800_PARAMS, sizeof(RSA_43800_PARAMS) / sizeof(RSA_43800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_43800_PARAMS); } -static const struct HksParam RSA_43900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest43900 - * @tc.name : HksRsaMtTest43900 + * @tc.number : HksRsaSha384WithRsaMt43900 + * @tc.name : HksRsaSha384WithRsaMt43900 * @tc.desc : Test huks Verify (768/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest43900, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt43900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_43900_PARAMS, sizeof(RSA_43900_PARAMS) / sizeof(RSA_43900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_43900_PARAMS); } -static const struct HksParam RSA_44000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44000 - * @tc.name : HksRsaMtTest44000 + * @tc.number : HksRsaSha384WithRsaMt44000 + * @tc.name : HksRsaSha384WithRsaMt44000 * @tc.desc : Test huks Verify (768/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44000, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44000_PARAMS, sizeof(RSA_44000_PARAMS) / sizeof(RSA_44000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_44000_PARAMS); } -static const struct HksParam RSA_44100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44100 - * @tc.name : HksRsaMtTest44100 + * @tc.number : HksRsaSha384WithRsaMt44100 + * @tc.name : HksRsaSha384WithRsaMt44100 * @tc.desc : Test huks sign (1024/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44100, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44100_PARAMS, sizeof(RSA_44100_PARAMS) / sizeof(RSA_44100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_44100_PARAMS); } -static const struct HksParam RSA_44200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44200 - * @tc.name : HksRsaMtTest44200 + * @tc.number : HksRsaSha384WithRsaMt44200 + * @tc.name : HksRsaSha384WithRsaMt44200 * @tc.desc : Test huks sign (1024/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44200, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44200_PARAMS, sizeof(RSA_44200_PARAMS) / sizeof(RSA_44200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_44200_PARAMS); } -static const struct HksParam RSA_44300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44300 - * @tc.name : HksRsaMtTest44300 + * @tc.number : HksRsaSha384WithRsaMt44300 + * @tc.name : HksRsaSha384WithRsaMt44300 * @tc.desc : Test huks Verify (1024/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44300, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44300_PARAMS, sizeof(RSA_44300_PARAMS) / sizeof(RSA_44300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_44300_PARAMS); } -static const struct HksParam RSA_44400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44400 - * @tc.name : HksRsaMtTest44400 + * @tc.number : HksRsaSha384WithRsaMt44400 + * @tc.name : HksRsaSha384WithRsaMt44400 * @tc.desc : Test huks Verify (1024/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44400, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44400_PARAMS, sizeof(RSA_44400_PARAMS) / sizeof(RSA_44400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_44400_PARAMS); } -static const struct HksParam RSA_44500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44500 - * @tc.name : HksRsaMtTest44500 + * @tc.number : HksRsaSha384WithRsaMt44500 + * @tc.name : HksRsaSha384WithRsaMt44500 * @tc.desc : Test huks sign (2048/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44500, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44500_PARAMS, sizeof(RSA_44500_PARAMS) / sizeof(RSA_44500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_44500_PARAMS); } -static const struct HksParam RSA_44600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44600 - * @tc.name : HksRsaMtTest44600 + * @tc.number : HksRsaSha384WithRsaMt44600 + * @tc.name : HksRsaSha384WithRsaMt44600 * @tc.desc : Test huks sign (2048/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44600, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44600_PARAMS, sizeof(RSA_44600_PARAMS) / sizeof(RSA_44600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_44600_PARAMS); } -static const struct HksParam RSA_44700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44700 - * @tc.name : HksRsaMtTest44700 + * @tc.number : HksRsaSha384WithRsaMt44700 + * @tc.name : HksRsaSha384WithRsaMt44700 * @tc.desc : Test huks Verify (2048/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44700, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44700_PARAMS, sizeof(RSA_44700_PARAMS) / sizeof(RSA_44700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_44700_PARAMS); } -static const struct HksParam RSA_44800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44800 - * @tc.name : HksRsaMtTest44800 + * @tc.number : HksRsaSha384WithRsaMt44800 + * @tc.name : HksRsaSha384WithRsaMt44800 * @tc.desc : Test huks Verify (2048/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44800, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44800_PARAMS, sizeof(RSA_44800_PARAMS) / sizeof(RSA_44800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_44800_PARAMS); } -static const struct HksParam RSA_44900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest44900 - * @tc.name : HksRsaMtTest44900 + * @tc.number : HksRsaSha384WithRsaMt44900 + * @tc.name : HksRsaSha384WithRsaMt44900 * @tc.desc : Test huks sign (3072/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest44900, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt44900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_44900_PARAMS, sizeof(RSA_44900_PARAMS) / sizeof(RSA_44900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_44900_PARAMS); } -static const struct HksParam RSA_45000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest45000 - * @tc.name : HksRsaMtTest45000 + * @tc.number : HksRsaSha384WithRsaMt45000 + * @tc.name : HksRsaSha384WithRsaMt45000 * @tc.desc : Test huks sign (3072/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45000, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45000_PARAMS, sizeof(RSA_45000_PARAMS) / sizeof(RSA_45000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_45000_PARAMS); } -static const struct HksParam RSA_45100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest45100 - * @tc.name : HksRsaMtTest45100 + * @tc.number : HksRsaSha384WithRsaMt45100 + * @tc.name : HksRsaSha384WithRsaMt45100 * @tc.desc : Test huks Verify (3072/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45100, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45100_PARAMS, sizeof(RSA_45100_PARAMS) / sizeof(RSA_45100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_45100_PARAMS); } -static const struct HksParam RSA_45200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest45200 - * @tc.name : HksRsaMtTest45200 + * @tc.number : HksRsaSha384WithRsaMt45200 + * @tc.name : HksRsaSha384WithRsaMt45200 * @tc.desc : Test huks Verify (3072/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45200, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45200_PARAMS, sizeof(RSA_45200_PARAMS) / sizeof(RSA_45200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_45200_PARAMS); } -static const struct HksParam RSA_45300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest45300 - * @tc.name : HksRsaMtTest45300 + * @tc.number : HksRsaSha384WithRsaMt45300 + * @tc.name : HksRsaSha384WithRsaMt45300 * @tc.desc : Test huks sign (4096/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45300, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45300_PARAMS, sizeof(RSA_45300_PARAMS) / sizeof(RSA_45300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_45300_PARAMS); } -static const struct HksParam RSA_45400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest45400 - * @tc.name : HksRsaMtTest45400 + * @tc.number : HksRsaSha384WithRsaMt45400 + * @tc.name : HksRsaSha384WithRsaMt45400 * @tc.desc : Test huks sign (4096/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45400, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45400_PARAMS, sizeof(RSA_45400_PARAMS) / sizeof(RSA_45400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_45400_PARAMS); } -static const struct HksParam RSA_45500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest45500 - * @tc.name : HksRsaMtTest45500 + * @tc.number : HksRsaSha384WithRsaMt45500 + * @tc.name : HksRsaSha384WithRsaMt45500 * @tc.desc : Test huks Verify (4096/SHA384withRSA/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45500, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45500_PARAMS, sizeof(RSA_45500_PARAMS) / sizeof(RSA_45500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_45500_PARAMS); } -static const struct HksParam RSA_45600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest45600 - * @tc.name : HksRsaMtTest45600 + * @tc.number : HksRsaSha384WithRsaMt45600 + * @tc.name : HksRsaSha384WithRsaMt45600 * @tc.desc : Test huks Verify (4096/SHA384withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaMt, HksRsaMtTest45600, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaMt, HksRsaSha384WithRsaMt45600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45600_PARAMS, sizeof(RSA_45600_PARAMS) / sizeof(RSA_45600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_45600_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp index 54232783..d7a3c518 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha384_with_rsa_pss_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1584 +25,767 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha384AndPss"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha384WithRsaPssMt : public testing::Test {}; -static const struct HksParam RSA_45700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_45700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif }; -/** - * @tc.number : HksRsaMtTest45700 - * @tc.name : HksRsaMtTest45700 - * @tc.desc : Test huks sign (512/SHA384withRSA/PSS/TEMP) - */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest45700, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45700_PARAMS, sizeof(RSA_45700_PARAMS) / sizeof(RSA_45700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_45800_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_45900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_46000_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_46100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_46200_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_46300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_46400_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_46500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); -#endif +const SignServiceCaseParams HKS_RSA_MT_46600_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyLocalCaseParams HKS_RSA_MT_46700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_45800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const VerifyServiceCaseParams HKS_RSA_MT_46800_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest45800 - * @tc.name : HksRsaMtTest45800 - * @tc.desc : Test huks sign (512/SHA384withRSA/PSS/PERSISTENT) - */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest45800, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignLocalCaseParams HKS_RSA_MT_46900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const SignServiceCaseParams HKS_RSA_MT_47000_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_45800_PARAMS, sizeof(RSA_45800_PARAMS) / sizeof(RSA_45800_PARAMS[0])), - HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_47100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_47200_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_47300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_47400_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyLocalCaseParams HKS_RSA_MT_47500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const VerifyServiceCaseParams HKS_RSA_MT_47600_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignLocalCaseParams HKS_RSA_MT_47700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignServiceCaseParams HKS_RSA_MT_47800_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyLocalCaseParams HKS_RSA_MT_47900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_48000_PARAMS = { + .alias = "This is a test auth id for Sha384AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA384, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); -#endif +class HksRsaSha384WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha384WithRsaPssMt45700 + * @tc.name : HksRsaSha384WithRsaPssMt45700 + * @tc.desc : Test huks sign (512/SHA384withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt45700, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_45700_PARAMS); } -static const struct HksParam RSA_45900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha384WithRsaPssMt45800 + * @tc.name : HksRsaSha384WithRsaPssMt45800 + * @tc.desc : Test huks sign (512/SHA384withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt45800, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_45800_PARAMS); +} /** - * @tc.number : HksRsaMtTest45900 - * @tc.name : HksRsaMtTest45900 + * @tc.number : HksRsaSha384WithRsaPssMt45900 + * @tc.name : HksRsaSha384WithRsaPssMt45900 * @tc.desc : Test huks Verify (512/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest45900, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt45900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_45900_PARAMS, sizeof(RSA_45900_PARAMS) / sizeof(RSA_45900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_45900_PARAMS); } -static const struct HksParam RSA_46000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46000 - * @tc.name : HksRsaMtTest46000 + * @tc.number : HksRsaSha384WithRsaPssMt46000 + * @tc.name : HksRsaSha384WithRsaPssMt46000 * @tc.desc : Test huks Verify (512/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46000, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46000_PARAMS, sizeof(RSA_46000_PARAMS) / sizeof(RSA_46000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_46000_PARAMS); } -static const struct HksParam RSA_46100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46100 - * @tc.name : HksRsaMtTest46100 + * @tc.number : HksRsaSha384WithRsaPssMt46100 + * @tc.name : HksRsaSha384WithRsaPssMt46100 * @tc.desc : Test huks sign (768/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46100, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46100_PARAMS, sizeof(RSA_46100_PARAMS) / sizeof(RSA_46100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_46100_PARAMS); } -static const struct HksParam RSA_46200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46200 - * @tc.name : HksRsaMtTest46200 + * @tc.number : HksRsaSha384WithRsaPssMt46200 + * @tc.name : HksRsaSha384WithRsaPssMt46200 * @tc.desc : Test huks sign (768/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46200, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46200_PARAMS, sizeof(RSA_46200_PARAMS) / sizeof(RSA_46200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_46200_PARAMS); } -static const struct HksParam RSA_46300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46300 - * @tc.name : HksRsaMtTest46300 + * @tc.number : HksRsaSha384WithRsaPssMt46300 + * @tc.name : HksRsaSha384WithRsaPssMt46300 * @tc.desc : Test huks Verify (768/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46300, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46300_PARAMS, sizeof(RSA_46300_PARAMS) / sizeof(RSA_46300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_46300_PARAMS); } -static const struct HksParam RSA_46400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46400 - * @tc.name : HksRsaMtTest46400 + * @tc.number : HksRsaSha384WithRsaPssMt46400 + * @tc.name : HksRsaSha384WithRsaPssMt46400 * @tc.desc : Test huks Verify (768/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46400, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46400_PARAMS, sizeof(RSA_46400_PARAMS) / sizeof(RSA_46400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_46400_PARAMS); } -static const struct HksParam RSA_46500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46500 - * @tc.name : HksRsaMtTest46500 + * @tc.number : HksRsaSha384WithRsaPssMt46500 + * @tc.name : HksRsaSha384WithRsaPssMt46500 * @tc.desc : Test huks sign (1024/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46500, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46500_PARAMS, sizeof(RSA_46500_PARAMS) / sizeof(RSA_46500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_46500_PARAMS); } -static const struct HksParam RSA_46600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46600 - * @tc.name : HksRsaMtTest46600 + * @tc.number : HksRsaSha384WithRsaPssMt46600 + * @tc.name : HksRsaSha384WithRsaPssMt46600 * @tc.desc : Test huks sign (1024/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46600, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46600_PARAMS, sizeof(RSA_46600_PARAMS) / sizeof(RSA_46600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_46600_PARAMS); } -static const struct HksParam RSA_46700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46700 - * @tc.name : HksRsaMtTest46700 + * @tc.number : HksRsaSha384WithRsaPssMt46700 + * @tc.name : HksRsaSha384WithRsaPssMt46700 * @tc.desc : Test huks Verify (1024/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46700, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46700_PARAMS, sizeof(RSA_46700_PARAMS) / sizeof(RSA_46700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_46700_PARAMS); } -static const struct HksParam RSA_46800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46800 - * @tc.name : HksRsaMtTest46800 + * @tc.number : HksRsaSha384WithRsaPssMt46800 + * @tc.name : HksRsaSha384WithRsaPssMt46800 * @tc.desc : Test huks Verify (1024/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46800, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46800_PARAMS, sizeof(RSA_46800_PARAMS) / sizeof(RSA_46800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_46800_PARAMS); } -static const struct HksParam RSA_46900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest46900 - * @tc.name : HksRsaMtTest46900 + * @tc.number : HksRsaSha384WithRsaPssMt46900 + * @tc.name : HksRsaSha384WithRsaPssMt46900 * @tc.desc : Test huks sign (2048/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest46900, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt46900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_46900_PARAMS, sizeof(RSA_46900_PARAMS) / sizeof(RSA_46900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_46900_PARAMS); } -static const struct HksParam RSA_47000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47000 - * @tc.name : HksRsaMtTest47000 + * @tc.number : HksRsaSha384WithRsaPssMt47000 + * @tc.name : HksRsaSha384WithRsaPssMt47000 * @tc.desc : Test huks sign (2048/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47000, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47000_PARAMS, sizeof(RSA_47000_PARAMS) / sizeof(RSA_47000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_47000_PARAMS); } -static const struct HksParam RSA_47100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47100 - * @tc.name : HksRsaMtTest47100 + * @tc.number : HksRsaSha384WithRsaPssMt47100 + * @tc.name : HksRsaSha384WithRsaPssMt47100 * @tc.desc : Test huks Verify (2048/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47100, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47100_PARAMS, sizeof(RSA_47100_PARAMS) / sizeof(RSA_47100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_47100_PARAMS); } -static const struct HksParam RSA_47200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47200 - * @tc.name : HksRsaMtTest47200 + * @tc.number : HksRsaSha384WithRsaPssMt47200 + * @tc.name : HksRsaSha384WithRsaPssMt47200 * @tc.desc : Test huks Verify (2048/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47200, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47200_PARAMS, sizeof(RSA_47200_PARAMS) / sizeof(RSA_47200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_47200_PARAMS); } -static const struct HksParam RSA_47300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47300 - * @tc.name : HksRsaMtTest47300 + * @tc.number : HksRsaSha384WithRsaPssMt47300 + * @tc.name : HksRsaSha384WithRsaPssMt47300 * @tc.desc : Test huks sign (3072/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47300, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47300_PARAMS, sizeof(RSA_47300_PARAMS) / sizeof(RSA_47300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_47300_PARAMS); } -static const struct HksParam RSA_47400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47400 - * @tc.name : HksRsaMtTest47400 + * @tc.number : HksRsaSha384WithRsaPssMt47400 + * @tc.name : HksRsaSha384WithRsaPssMt47400 * @tc.desc : Test huks sign (3072/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47400, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47400_PARAMS, sizeof(RSA_47400_PARAMS) / sizeof(RSA_47400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_47400_PARAMS); } -static const struct HksParam RSA_47500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47500 - * @tc.name : HksRsaMtTest47500 + * @tc.number : HksRsaSha384WithRsaPssMt47500 + * @tc.name : HksRsaSha384WithRsaPssMt47500 * @tc.desc : Test huks Verify (3072/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47500, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47500_PARAMS, sizeof(RSA_47500_PARAMS) / sizeof(RSA_47500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_47500_PARAMS); } -static const struct HksParam RSA_47600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47600 - * @tc.name : HksRsaMtTest47600 + * @tc.number : HksRsaSha384WithRsaPssMt47600 + * @tc.name : HksRsaSha384WithRsaPssMt47600 * @tc.desc : Test huks Verify (3072/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47600, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47600_PARAMS, sizeof(RSA_47600_PARAMS) / sizeof(RSA_47600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_47600_PARAMS); } -static const struct HksParam RSA_47700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47700 - * @tc.name : HksRsaMtTest47700 + * @tc.number : HksRsaSha384WithRsaPssMt47700 + * @tc.name : HksRsaSha384WithRsaPssMt47700 * @tc.desc : Test huks sign (4096/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47700, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47700_PARAMS, sizeof(RSA_47700_PARAMS) / sizeof(RSA_47700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_47700_PARAMS); } -static const struct HksParam RSA_47800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47800 - * @tc.name : HksRsaMtTest47800 + * @tc.number : HksRsaSha384WithRsaPssMt47800 + * @tc.name : HksRsaSha384WithRsaPssMt47800 * @tc.desc : Test huks sign (4096/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47800, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47800_PARAMS, sizeof(RSA_47800_PARAMS) / sizeof(RSA_47800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_47800_PARAMS); } -static const struct HksParam RSA_47900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest47900 - * @tc.name : HksRsaMtTest47900 + * @tc.number : HksRsaSha384WithRsaPssMt47900 + * @tc.name : HksRsaSha384WithRsaPssMt47900 * @tc.desc : Test huks Verify (4096/SHA384withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest47900, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt47900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_47900_PARAMS, sizeof(RSA_47900_PARAMS) / sizeof(RSA_47900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_47900_PARAMS); } -static const struct HksParam RSA_48000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest48000 - * @tc.name : HksRsaMtTest48000 + * @tc.number : HksRsaSha384WithRsaPssMt48000 + * @tc.name : HksRsaSha384WithRsaPssMt48000 * @tc.desc : Test huks Verify (4096/SHA384withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaMtTest48000, TestSize.Level1) +HWTEST_F(HksRsaSha384WithRsaPssMt, HksRsaSha384WithRsaPssMt48000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48000_PARAMS, sizeof(RSA_48000_PARAMS) / sizeof(RSA_48000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA384), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_48000_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp index 70844fea..632d589f 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1564 +25,767 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for SHA512"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha512WithRsaMt : public testing::Test {}; -static const struct HksParam RSA_48100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_48100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif }; -/** - * @tc.number : HksRsaMtTest48100 - * @tc.name : HksRsaMtTest48100 - * @tc.desc : Test huks sign (512/SHA512withRSA/TEMP) - */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48100, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48100_PARAMS, sizeof(RSA_48100_PARAMS) / sizeof(RSA_48100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_48200_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_48300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_48400_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_48500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_48600_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_48700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const VerifyServiceCaseParams HKS_RSA_MT_48800_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignLocalCaseParams HKS_RSA_MT_48900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const SignServiceCaseParams HKS_RSA_MT_49000_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); -#endif +const VerifyLocalCaseParams HKS_RSA_MT_49100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyServiceCaseParams HKS_RSA_MT_49200_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_48200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_49300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest48200 - * @tc.name : HksRsaMtTest48200 - * @tc.desc : Test huks sign (512/SHA512withRSA/PERSISTENT) - */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48200, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignServiceCaseParams HKS_RSA_MT_49400_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const VerifyLocalCaseParams HKS_RSA_MT_49500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_48200_PARAMS, sizeof(RSA_48200_PARAMS) / sizeof(RSA_48200_PARAMS[0])), - HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_49600_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_49700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_49800_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_49900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyServiceCaseParams HKS_RSA_MT_50000_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const SignLocalCaseParams HKS_RSA_MT_50100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_50200_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_50300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_50400_PARAMS = { + .alias = "This is a test auth id for SHA512", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace -#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); -#endif +class HksRsaSha512WithRsaMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha512WithRsaMt48100 + * @tc.name : HksRsaSha512WithRsaMt48100 + * @tc.desc : Test huks sign (512/SHA512withRSA/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48100, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_48100_PARAMS); } -static const struct HksParam RSA_48300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha512WithRsaMt48200 + * @tc.name : HksRsaSha512WithRsaMt48200 + * @tc.desc : Test huks sign (512/SHA512withRSA/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48200, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_48200_PARAMS); +} /** - * @tc.number : HksRsaMtTest48300 - * @tc.name : HksRsaMtTest48300 + * @tc.number : HksRsaSha512WithRsaMt48300 + * @tc.name : HksRsaSha512WithRsaMt48300 * @tc.desc : Test huks Verify (512/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48300, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48300_PARAMS, sizeof(RSA_48300_PARAMS) / sizeof(RSA_48300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(paramSetOut); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_48300_PARAMS); } -static const struct HksParam RSA_48400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest48400 - * @tc.name : HksRsaMtTest48400 + * @tc.number : HksRsaSha512WithRsaMt48400 + * @tc.name : HksRsaSha512WithRsaMt48400 * @tc.desc : Test huks Verify (512/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48400, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48400, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48400_PARAMS, sizeof(RSA_48400_PARAMS) / sizeof(RSA_48400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ( - OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_48400_PARAMS); } -static const struct HksParam RSA_48500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest48500 - * @tc.name : HksRsaMtTest48500 + * @tc.number : HksRsaSha512WithRsaMt48500 + * @tc.name : HksRsaSha512WithRsaMt48500 * @tc.desc : Test huks sign (768/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48500, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48500_PARAMS, sizeof(RSA_48500_PARAMS) / sizeof(RSA_48500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_48500_PARAMS); } -static const struct HksParam RSA_48600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest48600 - * @tc.name : HksRsaMtTest48600 + * @tc.number : HksRsaSha512WithRsaMt48600 + * @tc.name : HksRsaSha512WithRsaMt48600 * @tc.desc : Test huks sign (768/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48600, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48600_PARAMS, sizeof(RSA_48600_PARAMS) / sizeof(RSA_48600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_48600_PARAMS); } -static const struct HksParam RSA_48700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest48700 - * @tc.name : HksRsaMtTest48700 + * @tc.number : HksRsaSha512WithRsaMt48700 + * @tc.name : HksRsaSha512WithRsaMt48700 * @tc.desc : Test huks Verify (768/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48700, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48700_PARAMS, sizeof(RSA_48700_PARAMS) / sizeof(RSA_48700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_48700_PARAMS); } -static const struct HksParam RSA_48800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest48800 - * @tc.name : HksRsaMtTest48800 + * @tc.number : HksRsaSha512WithRsaMt48800 + * @tc.name : HksRsaSha512WithRsaMt48800 * @tc.desc : Test huks Verify (768/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48800, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48800_PARAMS, sizeof(RSA_48800_PARAMS) / sizeof(RSA_48800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_48800_PARAMS); } -static const struct HksParam RSA_48900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest48900 - * @tc.name : HksRsaMtTest48900 + * @tc.number : HksRsaSha512WithRsaMt48900 + * @tc.name : HksRsaSha512WithRsaMt48900 * @tc.desc : Test huks sign (1024/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest48900, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt48900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_48900_PARAMS, sizeof(RSA_48900_PARAMS) / sizeof(RSA_48900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_48900_PARAMS); } -static const struct HksParam RSA_49000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49000 - * @tc.name : HksRsaMtTest49000 + * @tc.number : HksRsaSha512WithRsaMt49000 + * @tc.name : HksRsaSha512WithRsaMt49000 * @tc.desc : Test huks sign (1024/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49000, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49000_PARAMS, sizeof(RSA_49000_PARAMS) / sizeof(RSA_49000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_49000_PARAMS); } -static const struct HksParam RSA_49100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49100 - * @tc.name : HksRsaMtTest49100 + * @tc.number : HksRsaSha512WithRsaMt49100 + * @tc.name : HksRsaSha512WithRsaMt49100 * @tc.desc : Test huks Verify (1024/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49100, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49100_PARAMS, sizeof(RSA_49100_PARAMS) / sizeof(RSA_49100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_49100_PARAMS); } -static const struct HksParam RSA_49200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49200 - * @tc.name : HksRsaMtTest49200 + * @tc.number : HksRsaSha512WithRsaMt49200 + * @tc.name : HksRsaSha512WithRsaMt49200 * @tc.desc : Test huks Verify (1024/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49200, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49200_PARAMS, sizeof(RSA_49200_PARAMS) / sizeof(RSA_49200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_49200_PARAMS); } -static const struct HksParam RSA_49300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49300 - * @tc.name : HksRsaMtTest49300 + * @tc.number : HksRsaSha512WithRsaMt49300 + * @tc.name : HksRsaSha512WithRsaMt49300 * @tc.desc : Test huks sign (2048/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49300, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49300_PARAMS, sizeof(RSA_49300_PARAMS) / sizeof(RSA_49300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_49300_PARAMS); } -static const struct HksParam RSA_49400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49400 - * @tc.name : HksRsaMtTest49400 + * @tc.number : HksRsaSha512WithRsaMt49400 + * @tc.name : HksRsaSha512WithRsaMt49400 * @tc.desc : Test huks sign (2048/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49400, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49400_PARAMS, sizeof(RSA_49400_PARAMS) / sizeof(RSA_49400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_49400_PARAMS); } -static const struct HksParam RSA_49500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49500 - * @tc.name : HksRsaMtTest49500 + * @tc.number : HksRsaSha512WithRsaMt49500 + * @tc.name : HksRsaSha512WithRsaMt49500 * @tc.desc : Test huks Verify (2048/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49500, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49500_PARAMS, sizeof(RSA_49500_PARAMS) / sizeof(RSA_49500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_49500_PARAMS); } -static const struct HksParam RSA_49600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49600 - * @tc.name : HksRsaMtTest49600 + * @tc.number : HksRsaSha512WithRsaMt49600 + * @tc.name : HksRsaSha512WithRsaMt49600 * @tc.desc : Test huks Verify (2048/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49600, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49600_PARAMS, sizeof(RSA_49600_PARAMS) / sizeof(RSA_49600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_49600_PARAMS); } -static const struct HksParam RSA_49700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49700 - * @tc.name : HksRsaMtTest49700 + * @tc.number : HksRsaSha512WithRsaMt49700 + * @tc.name : HksRsaSha512WithRsaMt49700 * @tc.desc : Test huks sign (3072/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49700, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49700_PARAMS, sizeof(RSA_49700_PARAMS) / sizeof(RSA_49700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_49700_PARAMS); } -static const struct HksParam RSA_49800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49800 - * @tc.name : HksRsaMtTest49800 + * @tc.number : HksRsaSha512WithRsaMt49800 + * @tc.name : HksRsaSha512WithRsaMt49800 * @tc.desc : Test huks sign (3072/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49800, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49800_PARAMS, sizeof(RSA_49800_PARAMS) / sizeof(RSA_49800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_49800_PARAMS); } -static const struct HksParam RSA_49900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest49900 - * @tc.name : HksRsaMtTest49900 + * @tc.number : HksRsaSha512WithRsaMt49900 + * @tc.name : HksRsaSha512WithRsaMt49900 * @tc.desc : Test huks Verify (3072/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest49900, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt49900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_49900_PARAMS, sizeof(RSA_49900_PARAMS) / sizeof(RSA_49900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_49900_PARAMS); } -static const struct HksParam RSA_50000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest50000 - * @tc.name : HksRsaMtTest50000 + * @tc.number : HksRsaSha512WithRsaMt50000 + * @tc.name : HksRsaSha512WithRsaMt50000 * @tc.desc : Test huks Verify (3072/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50000, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50000_PARAMS, sizeof(RSA_50000_PARAMS) / sizeof(RSA_50000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_50000_PARAMS); } -static const struct HksParam RSA_50100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest50100 - * @tc.name : HksRsaMtTest50100 + * @tc.number : HksRsaSha512WithRsaMt50100 + * @tc.name : HksRsaSha512WithRsaMt50100 * @tc.desc : Test huks sign (4096/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50100, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50100_PARAMS, sizeof(RSA_50100_PARAMS) / sizeof(RSA_50100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_50100_PARAMS); } -static const struct HksParam RSA_50200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest50200 - * @tc.name : HksRsaMtTest50200 + * @tc.number : HksRsaSha512WithRsaMt50200 + * @tc.name : HksRsaSha512WithRsaMt50200 * @tc.desc : Test huks sign (4096/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50200, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50200_PARAMS, sizeof(RSA_50200_PARAMS) / sizeof(RSA_50200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_50200_PARAMS); } -static const struct HksParam RSA_50300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest50300 - * @tc.name : HksRsaMtTest50300 + * @tc.number : HksRsaSha512WithRsaMt50300 + * @tc.name : HksRsaSha512WithRsaMt50300 * @tc.desc : Test huks Verify (4096/SHA512withRSA/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50300, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50300_PARAMS, sizeof(RSA_50300_PARAMS) / sizeof(RSA_50300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_50300_PARAMS); } -static const struct HksParam RSA_50400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest50400 - * @tc.name : HksRsaMtTest50400 + * @tc.number : HksRsaSha512WithRsaMt50400 + * @tc.name : HksRsaSha512WithRsaMt50400 * @tc.desc : Test huks Verify (4096/SHA512withRSA/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaMt, HksRsaMtTest50400, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaMt, HksRsaSha512WithRsaMt50400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50400_PARAMS, sizeof(RSA_50400_PARAMS) / sizeof(RSA_50400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_50400_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp index ba264a99..86b0ad4b 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/hks_rsa_sha512_with_rsa_pss_mt.cpp @@ -13,7 +13,11 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" +#include "hks_rsa_common_mt.h" + +#include +#include #include @@ -21,1572 +25,775 @@ #include "hks_mem.h" using namespace testing::ext; +namespace OHOS { +namespace Security { +namespace Huks { +namespace MT { namespace { -namespace { -const char TEST_KEY_AUTH_ID[] = "This is a test auth id for Sha512AndPss"; const int SET_SIZE_4096 = 4096; const int KEY_SIZE_512 = 512; const int KEY_SIZE_768 = 768; const int KEY_SIZE_1024 = 1024; const int KEY_SIZE_2048 = 2048; const int KEY_SIZE_3072 = 3072; -} // namespace - -class HksRsaSha512WithRsaPssMt : public testing::Test {}; -static const struct HksParam RSA_50500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_50500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif }; -/** - * @tc.number : HksRsaMtTest50500 - * @tc.name : HksRsaMtTest50500 - * @tc.desc : Test huks sign (512/SHA512withRSA/PSS/TEMP) - */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50500, TestSize.Level1) -{ - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50500_PARAMS, sizeof(RSA_50500_PARAMS) / sizeof(RSA_50500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_50600_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_50700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_50800_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_FAILURE, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); +const SignLocalCaseParams HKS_RSA_MT_50900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_51000_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, +#if defined(_USE_MBEDTLS_) + .signResult = HKS_ERROR_CRYPTO_ENGINE_ERROR, +#else + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +#endif +}; - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); +const VerifyLocalCaseParams HKS_RSA_MT_51100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const VerifyServiceCaseParams HKS_RSA_MT_51200_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_768, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const SignLocalCaseParams HKS_RSA_MT_51300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const SignServiceCaseParams HKS_RSA_MT_51400_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); -#endif +const VerifyLocalCaseParams HKS_RSA_MT_51500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); -} +const VerifyServiceCaseParams HKS_RSA_MT_51600_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_1024, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; -static const struct HksParam RSA_50600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, +const SignLocalCaseParams HKS_RSA_MT_51700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, }; -/** - * @tc.number : HksRsaMtTest50600 - * @tc.name : HksRsaMtTest50600 - * @tc.desc : Test huks sign (512/SHA512withRSA/PSS/PERSISTENT) - */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50600, TestSize.Level1) -{ - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); +const SignServiceCaseParams HKS_RSA_MT_51800_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; +const VerifyLocalCaseParams HKS_RSA_MT_51900_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksAddParams(paramInSet, RSA_50600_PARAMS, sizeof(RSA_50600_PARAMS) / sizeof(RSA_50600_PARAMS[0])), - HKS_SUCCESS); +const VerifyServiceCaseParams HKS_RSA_MT_52000_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_2048, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); +const SignLocalCaseParams HKS_RSA_MT_52100_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); +const SignServiceCaseParams HKS_RSA_MT_52200_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); +const VerifyLocalCaseParams HKS_RSA_MT_52300_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); +const VerifyServiceCaseParams HKS_RSA_MT_52400_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = KEY_SIZE_3072, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); +const SignLocalCaseParams HKS_RSA_MT_52500_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - const char *hexData = "00112233445566778899aabbccddeeff"; +const SignServiceCaseParams HKS_RSA_MT_52600_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; +const VerifyLocalCaseParams HKS_RSA_MT_52700_PARAMS = { + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); +const VerifyServiceCaseParams HKS_RSA_MT_52800_PARAMS = { + .alias = "This is a test auth id for Sha512AndPss", + .params = + { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, + }, + .padding = RSA_PKCS1_PSS_PADDING, + .keyDigest = HKS_DIGEST_SHA512, + .keySize = SET_SIZE_4096, + .generateKeyResult = HKS_SUCCESS, + .signResult = HKS_SUCCESS, + .verifyResult = HKS_SUCCESS, +}; +} // namespace -#if (defined(_USE_OPENSSL_) || defined(_USE_MBEDTLS_)) - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); -#endif +class HksRsaSha512WithRsaPssMt : public HksRsaCommonMt, public testing::Test {}; - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); +/** + * @tc.number : HksRsaSha512WithRsaPssMt50500 + * @tc.name : HksRsaSha512WithRsaPssMt50500 + * @tc.desc : Test huks sign (512/SHA512withRSA/PSS/TEMP) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50500, TestSize.Level1) +{ + SignLocalTestCase(HKS_RSA_MT_50500_PARAMS); } -static const struct HksParam RSA_50700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; +/** + * @tc.number : HksRsaSha512WithRsaPssMt50600 + * @tc.name : HksRsaSha512WithRsaPssMt50600 + * @tc.desc : Test huks sign (512/SHA512withRSA/PSS/PERSISTENT) + */ +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50600, TestSize.Level1) +{ + SignServiceTestCase(HKS_RSA_MT_50600_PARAMS); +} /** - * @tc.number : HksRsaMtTest50700 - * @tc.name : HksRsaMtTest50700 + * @tc.number : HksRsaSha512WithRsaPssMt50700 + * @tc.name : HksRsaSha512WithRsaPssMt50700 * @tc.desc : Test huks Verify (512/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50700, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50700_PARAMS, sizeof(RSA_50700_PARAMS) / sizeof(RSA_50700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), RSA_FAILED); - - free(paramSetOut); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_50700_PARAMS); } -static const struct HksParam RSA_50800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest50800 - * @tc.name : HksRsaMtTest50800 + * @tc.number : HksRsaSha512WithRsaPssMt50800 + * @tc.name : HksRsaSha512WithRsaPssMt50800 * @tc.desc : Test huks Verify (512/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50800, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50800, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50800_PARAMS, sizeof(RSA_50800_PARAMS) / sizeof(RSA_50800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_512); - ASSERT_NE(pkey, nullptr); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_512, &opensslRsaKeyInfo); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), - RSA_FAILED); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_50800_PARAMS); } -static const struct HksParam RSA_50900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest50900 - * @tc.name : HksRsaMtTest50900 + * @tc.number : HksRsaSha512WithRsaPssMt50900 + * @tc.name : HksRsaSha512WithRsaPssMt50900 * @tc.desc : Test huks sign (768/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest50900, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt50900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_50900_PARAMS, sizeof(RSA_50900_PARAMS) / sizeof(RSA_50900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); -#endif - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_50900_PARAMS); } -static const struct HksParam RSA_51000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51000 - * @tc.name : HksRsaMtTest51000 + * @tc.number : HksRsaSha512WithRsaPssMt51000 + * @tc.name : HksRsaSha512WithRsaPssMt51000 * @tc.desc : Test huks sign (768/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51000, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51000_PARAMS, sizeof(RSA_51000_PARAMS) / sizeof(RSA_51000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - -#if defined(_USE_MBEDTLS_) - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_ERROR_CRYPTO_ENGINE_ERROR); -#else - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); -#endif - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_51000_PARAMS); } -static const struct HksParam RSA_51100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51100 - * @tc.name : HksRsaMtTest51100 + * @tc.number : HksRsaSha512WithRsaPssMt51100 + * @tc.name : HksRsaSha512WithRsaPssMt51100 * @tc.desc : Test huks Verify (768/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51100, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51100_PARAMS, sizeof(RSA_51100_PARAMS) / sizeof(RSA_51100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_51100_PARAMS); } -static const struct HksParam RSA_51200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51200 - * @tc.name : HksRsaMtTest51200 + * @tc.number : HksRsaSha512WithRsaPssMt51200 + * @tc.name : HksRsaSha512WithRsaPssMt51200 * @tc.desc : Test huks Verify (768/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51200, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51200_PARAMS, sizeof(RSA_51200_PARAMS) / sizeof(RSA_51200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_768); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_768, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_51200_PARAMS); } -static const struct HksParam RSA_51300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51300 - * @tc.name : HksRsaMtTest51300 + * @tc.number : HksRsaSha512WithRsaPssMt51300 + * @tc.name : HksRsaSha512WithRsaPssMt51300 * @tc.desc : Test huks sign (1024/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51300, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51300_PARAMS, sizeof(RSA_51300_PARAMS) / sizeof(RSA_51300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_51300_PARAMS); } -static const struct HksParam RSA_51400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51400 - * @tc.name : HksRsaMtTest51400 + * @tc.number : HksRsaSha512WithRsaPssMt51400 + * @tc.name : HksRsaSha512WithRsaPssMt51400 * @tc.desc : Test huks sign (1024/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51400, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51400_PARAMS, sizeof(RSA_51400_PARAMS) / sizeof(RSA_51400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_51400_PARAMS); } -static const struct HksParam RSA_51500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51500 - * @tc.name : HksRsaMtTest51500 + * @tc.number : HksRsaSha512WithRsaPssMt51500 + * @tc.name : HksRsaSha512WithRsaPssMt51500 * @tc.desc : Test huks Verify (1024/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51500, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51500_PARAMS, sizeof(RSA_51500_PARAMS) / sizeof(RSA_51500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_51500_PARAMS); } -static const struct HksParam RSA_51600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51600 - * @tc.name : HksRsaMtTest51600 + * @tc.number : HksRsaSha512WithRsaPssMt51600 + * @tc.name : HksRsaSha512WithRsaPssMt51600 * @tc.desc : Test huks Verify (1024/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51600, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51600_PARAMS, sizeof(RSA_51600_PARAMS) / sizeof(RSA_51600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_1024); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_1024, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_51600_PARAMS); } -static const struct HksParam RSA_51700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51700 - * @tc.name : HksRsaMtTest51700 + * @tc.number : HksRsaSha512WithRsaPssMt51700 + * @tc.name : HksRsaSha512WithRsaPssMt51700 * @tc.desc : Test huks sign (2048/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51700, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51700_PARAMS, sizeof(RSA_51700_PARAMS) / sizeof(RSA_51700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_51700_PARAMS); } -static const struct HksParam RSA_51800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51800 - * @tc.name : HksRsaMtTest51800 + * @tc.number : HksRsaSha512WithRsaPssMt51800 + * @tc.name : HksRsaSha512WithRsaPssMt51800 * @tc.desc : Test huks sign (2048/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51800, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51800_PARAMS, sizeof(RSA_51800_PARAMS) / sizeof(RSA_51800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_51800_PARAMS); } -static const struct HksParam RSA_51900_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest51900 - * @tc.name : HksRsaMtTest51900 + * @tc.number : HksRsaSha512WithRsaPssMt51900 + * @tc.name : HksRsaSha512WithRsaPssMt51900 * @tc.desc : Test huks Verify (2048/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest51900, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt51900, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_51900_PARAMS, sizeof(RSA_51900_PARAMS) / sizeof(RSA_51900_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_51900_PARAMS); } -static const struct HksParam RSA_52000_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52000 - * @tc.name : HksRsaMtTest52000 + * @tc.number : HksRsaSha512WithRsaPssMt52000 + * @tc.name : HksRsaSha512WithRsaPssMt52000 * @tc.desc : Test huks Verify (2048/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52000, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52000, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52000_PARAMS, sizeof(RSA_52000_PARAMS) / sizeof(RSA_52000_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_2048); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_2048, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_52000_PARAMS); } -static const struct HksParam RSA_52100_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52100 - * @tc.name : HksRsaMtTest52100 + * @tc.number : HksRsaSha512WithRsaPssMt52100 + * @tc.name : HksRsaSha512WithRsaPssMt52100 * @tc.desc : Test huks sign (3072/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52100, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52100, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52100_PARAMS, sizeof(RSA_52100_PARAMS) / sizeof(RSA_52100_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_52100_PARAMS); } -static const struct HksParam RSA_52200_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52200 - * @tc.name : HksRsaMtTest52200 + * @tc.number : HksRsaSha512WithRsaPssMt52200 + * @tc.name : HksRsaSha512WithRsaPssMt52200 * @tc.desc : Test huks sign (3072/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52200, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52200, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52200_PARAMS, sizeof(RSA_52200_PARAMS) / sizeof(RSA_52200_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_52200_PARAMS); } -static const struct HksParam RSA_52300_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52300 - * @tc.name : HksRsaMtTest52300 + * @tc.number : HksRsaSha512WithRsaPssMt52300 + * @tc.name : HksRsaSha512WithRsaPssMt52300 * @tc.desc : Test huks Verify (3072/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52300, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52300, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52300_PARAMS, sizeof(RSA_52300_PARAMS) / sizeof(RSA_52300_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_52300_PARAMS); } -static const struct HksParam RSA_52400_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52400 - * @tc.name : HksRsaMtTest52400 + * @tc.number : HksRsaSha512WithRsaPssMt52400 + * @tc.name : HksRsaSha512WithRsaPssMt52400 * @tc.desc : Test huks Verify (3072/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52400, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52400, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52400_PARAMS, sizeof(RSA_52400_PARAMS) / sizeof(RSA_52400_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(KEY_SIZE_3072); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, KEY_SIZE_3072, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_52400_PARAMS); } -static const struct HksParam RSA_52500_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52500 - * @tc.name : HksRsaMtTest52500 + * @tc.number : HksRsaSha512WithRsaPssMt52500 + * @tc.name : HksRsaSha512WithRsaPssMt52500 * @tc.desc : Test huks sign (4096/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52500, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52500, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52500_PARAMS, sizeof(RSA_52500_PARAMS) / sizeof(RSA_52500_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&privateKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignLocalTestCase(HKS_RSA_MT_52500_PARAMS); } -static const struct HksParam RSA_52600_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY | HKS_KEY_PURPOSE_SIGN }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52600 - * @tc.name : HksRsaMtTest52600 + * @tc.number : HksRsaSha512WithRsaPssMt52600 + * @tc.name : HksRsaSha512WithRsaPssMt52600 * @tc.desc : Test huks sign (4096/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52600, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52600, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52600_PARAMS, sizeof(RSA_52600_PARAMS) / sizeof(RSA_52600_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(&authId, paramInSet, paramSetOut), HKS_SUCCESS); - - uint8_t opensslRsaKey[SET_SIZE_4096] = {0}; - uint32_t opensslRsaKeyLen = SET_SIZE_4096; - struct HksBlob opensslRsaKeyInfo = { opensslRsaKeyLen, opensslRsaKey }; - EXPECT_EQ(HksExportPublicKey(&authId, paramInSet, &opensslRsaKeyInfo), HKS_SUCCESS); - - uint8_t rsaPublicKey[SET_SIZE_4096] = {0}; - uint32_t rsaPublicKeyLen = SET_SIZE_4096; - struct HksBlob rsaPublicKeyInfo = { rsaPublicKeyLen, rsaPublicKey }; - EXPECT_EQ(X509ToRsaPublicKey(&opensslRsaKeyInfo, &rsaPublicKeyInfo), 0); - - HksBlob publicKey = { .size = rsaPublicKeyInfo.size, .data = (uint8_t *)malloc(rsaPublicKeyInfo.size) }; - (void)memcpy_s(publicKey.data, publicKey.size, rsaPublicKeyInfo.data, rsaPublicKeyInfo.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(HksSign(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EXPECT_EQ(OpensslVerifyRsa(&plainText, &signData, &publicKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - free(paramSetOut); - free(publicKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + SignServiceTestCase(HKS_RSA_MT_52600_PARAMS); } -static const struct HksParam RSA_52700_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52700 - * @tc.name : HksRsaMtTest52700 + * @tc.number : HksRsaSha512WithRsaPssMt52700 + * @tc.name : HksRsaSha512WithRsaPssMt52700 * @tc.desc : Test huks Verify (4096/SHA512withRSA/PSS/TEMP) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52700, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52700, TestSize.Level1) { - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - struct HksParamSet *paramSetOut = (struct HksParamSet *)malloc(SET_SIZE_4096); - ASSERT_NE(paramSetOut, nullptr); - (void)memset_s(paramSetOut, SET_SIZE_4096, 0, SET_SIZE_4096); - paramSetOut->paramSetSize = SET_SIZE_4096; - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52700_PARAMS, sizeof(RSA_52700_PARAMS) / sizeof(RSA_52700_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - EXPECT_EQ(HksGenerateKey(NULL, paramInSet, paramSetOut), HKS_SUCCESS); - - HksParam *pubKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubKeyExport), HKS_SUCCESS); - - HksBlob publicKey = { .size = pubKeyExport->blob.size, .data = (uint8_t *)malloc(pubKeyExport->blob.size) }; - ASSERT_NE(publicKey.data, nullptr); - (void)memcpy_s(publicKey.data, pubKeyExport->blob.size, pubKeyExport->blob.data, pubKeyExport->blob.size); - - HksParam *priKeyExport = NULL; - EXPECT_EQ(HksGetParam(paramSetOut, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priKeyExport), HKS_SUCCESS); - - HksBlob privateKey = { .size = priKeyExport->blob.size, .data = (uint8_t *)malloc(priKeyExport->blob.size) }; - ASSERT_NE(privateKey.data, nullptr); - (void)memcpy_s(privateKey.data, priKeyExport->blob.size, priKeyExport->blob.data, priKeyExport->blob.size); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &privateKey, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&publicKey, paramInSet, &plainText, &signData), HKS_SUCCESS); - - free(paramSetOut); - free(publicKey.data); - free(privateKey.data); - free(signData.data); - HksFreeParamSet(¶mInSet); + VerifyLocalTestCase(HKS_RSA_MT_52700_PARAMS); } -static const struct HksParam RSA_52800_PARAMS[] = { - { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, - { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }, - { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }, - { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, - { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }, - { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }, - { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, - { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, - { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }, -}; - /** - * @tc.number : HksRsaMtTest52800 - * @tc.name : HksRsaMtTest52800 + * @tc.number : HksRsaSha512WithRsaPssMt52800 + * @tc.name : HksRsaSha512WithRsaPssMt52800 * @tc.desc : Test huks Verify (4096/SHA512withRSA/PSS/PERSISTENT) */ -HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaMtTest52800, TestSize.Level1) +HWTEST_F(HksRsaSha512WithRsaPssMt, HksRsaSha512WithRsaPssMt52800, TestSize.Level1) { - struct HksBlob authId = { strlen(TEST_KEY_AUTH_ID), (uint8_t *)TEST_KEY_AUTH_ID }; - - struct HksParamSet *paramInSet = NULL; - HksInitParamSet(¶mInSet); - ASSERT_NE(paramInSet, nullptr); - - EXPECT_EQ(HksAddParams(paramInSet, RSA_52800_PARAMS, sizeof(RSA_52800_PARAMS) / sizeof(RSA_52800_PARAMS[0])), - HKS_SUCCESS); - - EXPECT_EQ(HksBuildParamSet(¶mInSet), HKS_SUCCESS); - - const char *hexData = "00112233445566778899aabbccddeeff"; - - HksBlob plainText = { .size = strlen(hexData), .data = (uint8_t *)hexData }; - - HksBlob signData = { .size = SET_SIZE_4096, .data = (uint8_t *)malloc(SET_SIZE_4096) }; - ASSERT_NE(signData.data, nullptr); - - struct HksBlob opensslRsaKeyInfo = { .size = SET_SIZE_4096, .data = (uint8_t *)calloc(1, SET_SIZE_4096) }; - ASSERT_NE(opensslRsaKeyInfo.data, nullptr); - - struct HksBlob x509Key = { 0, NULL }; - - EVP_PKEY *pkey = GenerateRSAKey(SET_SIZE_4096); - ASSERT_NE(pkey, nullptr); - - OpensslGetx509PubKey(pkey, &x509Key); - - EXPECT_EQ(HksImportKey(&authId, paramInSet, &x509Key), HKS_SUCCESS); - - SaveRsaKeyToHksBlob(pkey, SET_SIZE_4096, &opensslRsaKeyInfo); - EXPECT_EQ(OpensslSignRsa(&plainText, &signData, &opensslRsaKeyInfo, RSA_PKCS1_PSS_PADDING, HKS_DIGEST_SHA512), 0); - - EXPECT_EQ(HksVerify(&authId, paramInSet, &plainText, &signData), HKS_SUCCESS); - - EVP_PKEY_free(pkey); - free(signData.data); - free(opensslRsaKeyInfo.data); - HksFreeParamSet(¶mInSet); + VerifyServiceTestCase(HKS_RSA_MT_52800_PARAMS); } -} // namespace \ No newline at end of file +} // namespace MT +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_aes_test_mt.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_aes_helper.c similarity index 83% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_aes_test_mt.c rename to interfaces/innerkits/huks_standard/test/moduletest/src/openssl_aes_helper.c index 509917c2..d5fc6438 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_aes_test_mt.c +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_aes_helper.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "hks_openssl_aes_test_mt.h" +#include "openssl_aes_helper.h" #include @@ -25,14 +25,19 @@ int32_t GenerateAesKey(const int keyLen, struct HksBlob *randomKey) uint32_t keySize = keyLen / BIT_NUM_OF_UINT8; uint8_t *Key = (uint8_t *)malloc(keySize); do { - if (RAND_bytes(Key, keySize) <= 0) { - return AES_FAILED; + if (RAND_bytes(Key, keySize) != 1) { + free(Key); + return HKS_FAILURE; } - randomKey->data = Key; randomKey->size = keySize; + if (memcpy_s(randomKey->data, randomKey->size, Key, keySize) != 0) { + free(Key); + return HKS_FAILURE; + } } while (0); - return AES_SUCCESS; + free(Key); + return HKS_SUCCESS; } static const EVP_CIPHER *AesCBCCrypt(uint32_t keyLen) @@ -97,13 +102,12 @@ static uint32_t AesInit(EVP_CIPHER_CTX **ctx, const EVP_CIPHER **ciper, uint32_t *ctx = EVP_CIPHER_CTX_new(); if (*ctx == NULL) { - EVP_CIPHER_CTX_free(*ctx); - return AES_FAILED; + return HKS_FAILURE; } - return AES_SUCCESS; + return HKS_SUCCESS; } -uint32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, +int32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, const struct HksBlob *randomKey) { struct HksParam *mode = NULL; @@ -117,19 +121,19 @@ uint32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob * const EVP_CIPHER *ciper = NULL; EVP_CIPHER_CTX *ctx = NULL; - if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != AES_SUCCESS) { + if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_EncryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_EncryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } int ret = 1; @@ -146,19 +150,19 @@ uint32_t AesEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob * int outLen = 0; if (EVP_EncryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } outData->size = outLen; if (EVP_EncryptFinal_ex(ctx, outData->data + outLen, &outLen) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } outData->size += outLen; EVP_CIPHER_CTX_free(ctx); - return AES_SUCCESS; + return HKS_SUCCESS; } -uint32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, +int32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, const struct HksBlob *randomKey) { struct HksParam *mode = NULL; @@ -172,19 +176,19 @@ uint32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob * const EVP_CIPHER *ciper = NULL; EVP_CIPHER_CTX *ctx = NULL; - if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != AES_SUCCESS) { + if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_DecryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_DecryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } int ret = 1; @@ -201,19 +205,19 @@ uint32_t AesDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob * int outLen = 0; if (EVP_DecryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } outData->size = outLen; if (EVP_DecryptFinal_ex(ctx, outData->data + outLen, &outLen) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } outData->size += outLen; EVP_CIPHER_CTX_free(ctx); - return AES_SUCCESS; + return HKS_SUCCESS; } -uint32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, +int32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, const struct HksBlob *randomKey, const struct HksBlob *tagAead) { struct HksParam *mode = NULL; @@ -227,49 +231,49 @@ uint32_t AesGCMEncrypt(const struct HksParamSet *paramSetIn, const struct HksBlo const EVP_CIPHER *ciper = NULL; EVP_CIPHER_CTX *ctx = NULL; - if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != AES_SUCCESS) { + if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_EncryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv->blob.size, NULL) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_EncryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } int outLen = 0; if (EVP_EncryptUpdate(ctx, NULL, &outLen, aad->blob.data, aad->blob.size) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_EncryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } outData->size = outLen; if (EVP_EncryptFinal_ex(ctx, outData->data, &outLen) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, HKS_AE_TAG_LEN, tagAead->data) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } EVP_CIPHER_CTX_free(ctx); - return AES_SUCCESS; + return HKS_SUCCESS; } -uint32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, +int32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlob *inData, struct HksBlob *outData, const struct HksBlob *randomKey, const struct HksBlob *tagDec) { struct HksParam *mode = NULL; @@ -283,45 +287,45 @@ uint32_t AesGCMDecrypt(const struct HksParamSet *paramSetIn, const struct HksBlo const EVP_CIPHER *ciper = NULL; EVP_CIPHER_CTX *ctx = NULL; - if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != AES_SUCCESS) { + if (AesInit(&ctx, &ciper, mode->uint32Param, keyLen->uint32Param) != HKS_SUCCESS) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_DecryptInit_ex(ctx, ciper, NULL, NULL, NULL) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, iv->blob.size, NULL) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_DecryptInit_ex(ctx, NULL, NULL, randomKey->data, iv->blob.data) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } int outLen = 0; if (EVP_DecryptUpdate(ctx, NULL, &outLen, aad->blob.data, aad->blob.size) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_DecryptUpdate(ctx, outData->data, &outLen, inData->data, inData->size) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } outData->size = outLen; if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, tagDec->size, tagDec->data) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } if (EVP_DecryptFinal_ex(ctx, outData->data, &outLen) != 1) { EVP_CIPHER_CTX_free(ctx); - return AES_FAILED; + return HKS_FAILURE; } EVP_CIPHER_CTX_free(ctx); - return AES_SUCCESS; + return HKS_SUCCESS; } diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dh_mt_test.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dh_helper.c similarity index 87% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dh_mt_test.c rename to interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dh_helper.c index 52e921e4..cfa4fab2 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dh_mt_test.c +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dh_helper.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "hks_openssl_dh_mt_test.h" +#include "openssl_dh_helper.h" #include #include @@ -64,8 +64,12 @@ static int32_t DhSaveKeyMaterial(const DH *dh, const uint32_t keySize, struct Hk offset += keyMaterial->priKeySize; key->size = rawMaterialLen; - key->data = rawMaterial; + if (memcpy_s(key->data, key->size, rawMaterial, rawMaterialLen) != 0) { + free(rawMaterial); + return DH_FAILED; + } + free(rawMaterial); return DH_SUCCESS; } @@ -119,6 +123,12 @@ static DH *InitDhStruct(const struct HksBlob *key, const bool needPrivateExponen BIGNUM *privKey = BN_bin2bn(key->data + offset, keyMaterial->priKeySize, NULL); if (DH_set0_key(dh, pubKey, privKey) != 1) { + if (pubKey != NULL) { + BN_free(pubKey); + } + if (privKey != NULL) { + BN_free(privKey); + } DH_free(dh); return NULL; } @@ -130,19 +140,20 @@ int32_t DhAgreeKey( const int keyLen, const struct HksBlob *nativeKey, const struct HksBlob *pubKey, struct HksBlob *sharedKey) { int32_t ret; + if ((uint32_t)HKS_KEY_BYTES(keyLen) > sharedKey->size) { return DH_FAILED; } - struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data; - BIGNUM *pub = BN_bin2bn(pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL); - if (pub == NULL) { + DH *dh = InitDhStruct(nativeKey, true); + if (dh == NULL) { return DH_FAILED; } - DH *dh = InitDhStruct(nativeKey, true); - if (dh == NULL) { - BN_free(pub); + struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)pubKey->data; + BIGNUM *pub = BN_bin2bn(pubKey->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL); + if (pub == NULL) { + DH_free(dh); return DH_FAILED; } @@ -200,6 +211,7 @@ int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey DH *dh = EVP_PKEY_get0_DH(pkey); if (dh == NULL) { + EVP_PKEY_free(pkey); return DH_FAILED; } @@ -208,6 +220,7 @@ int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey uint8_t *keyBuffer = HksMalloc(sizeof(struct KeyMaterialDh) + dhpubKeySize); if (keyBuffer == NULL) { + EVP_PKEY_free(pkey); return DH_FAILED; } struct KeyMaterialDh *keyMaterial = (struct KeyMaterialDh *)keyBuffer; @@ -219,24 +232,22 @@ int32_t DhX509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey BN_bn2bin(pubKey, keyBuffer + sizeof(struct KeyMaterialDh)); - publicKey->size = dhpubKeySize; - publicKey->data = keyBuffer; + publicKey->size = sizeof(struct KeyMaterialDh) + dhpubKeySize; + if (memcpy_s(publicKey->data, publicKey->size, keyBuffer, sizeof(struct KeyMaterialDh) + dhpubKeySize) != 0) { + EVP_PKEY_free(pkey); + free(keyBuffer); + return DH_FAILED; + } - SELF_FREE_PTR(pkey, EVP_PKEY_free); + free(keyBuffer); + EVP_PKEY_free(pkey); return DH_SUCCESS; } int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key) { - struct KeyMaterialDh *pubKeyMaterial = (struct KeyMaterialDh *)key->data; - BIGNUM *pub = BN_bin2bn(key->data + sizeof(struct KeyMaterialDh), pubKeyMaterial->pubKeySize, NULL); - if (pub == NULL) { - return DH_FAILED; - } - DH *dh = InitDhStruct(key, true); if (dh == NULL) { - BN_free(pub); return DH_FAILED; } EVP_PKEY *pkey = EVP_PKEY_new(); @@ -245,7 +256,7 @@ int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key) return DH_FAILED; } - if (EVP_PKEY_assign_DH(pkey, dh) <= 0) { + if (EVP_PKEY_assign_DH(pkey, dh) != 1) { DH_free(dh); EVP_PKEY_free(pkey); return DH_FAILED; @@ -254,6 +265,17 @@ int32_t DhHksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key) uint8_t *tmp = NULL; int32_t length = i2d_PUBKEY(pkey, &tmp); x509Key->size = length; - x509Key->data = tmp; + if (tmp == NULL) { + EVP_PKEY_free(pkey); + return DH_FAILED; + } + if (memcpy_s(x509Key->data, x509Key->size, tmp, length) != 0) { + EVP_PKEY_free(pkey); + free(tmp); + return DH_FAILED; + } + + EVP_PKEY_free(pkey); + free(tmp); return DH_SUCCESS; } \ No newline at end of file diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dsa_sign_test_mt.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dsa_helper.c similarity index 74% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dsa_sign_test_mt.c rename to interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dsa_helper.c index 5a1c2c00..7da92a95 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_dsa_sign_test_mt.c +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_dsa_helper.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "hks_openssl_dsa_sign_test_mt.h" +#include "openssl_dsa_helper.h" #include #include @@ -27,70 +27,103 @@ EVP_PKEY *GenerateDsaKey(const uint32_t keySize) { - EVP_PKEY *pkey = EVP_PKEY_new(); - if (pkey == NULL) { - return NULL; - } DSA *dsa = DSA_new(); if (dsa == NULL) { - EVP_PKEY_free(pkey); return NULL; } if (DSA_generate_parameters_ex(dsa, keySize, NULL, 0, NULL, NULL, NULL) != 1) { - EVP_PKEY_free(pkey); DSA_free(dsa); return NULL; } if (DSA_generate_key(dsa) != 1) { - EVP_PKEY_free(pkey); DSA_free(dsa); return NULL; } - EVP_PKEY_assign_DSA(pkey, dsa); + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + DSA_free(dsa); + return NULL; + } + + if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) { + EVP_PKEY_free(pkey); + DSA_free(dsa); + return NULL; + } return pkey; } +static BIGNUM *BinToBN(uint8_t *data, uint32_t length) +{ + uint8_t buff[length]; + if (memcpy_s(buff, sizeof(buff), data, length) != 0) { + return NULL; + } + return BN_bin2bn(buff, length, NULL); +} + +static void FreeBN(BIGNUM *bn) +{ + if (bn != NULL) { + BN_free(bn); + } +} + static DSA *InitDsa(struct HksBlob *key, const bool needPrivateExponent) { const struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)(key->data); - uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)]; uint32_t offset = sizeof(*keyMaterial); BIGNUM *x = NULL; - if (needPrivateExponent) { - (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->xSize); - x = BN_bin2bn(buff, keyMaterial->xSize, NULL); - } + BIGNUM *y = NULL; + BIGNUM *p = NULL; + BIGNUM *q = NULL; + BIGNUM *g = NULL; - offset += keyMaterial->xSize; - if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->ySize) != 0) { - return NULL; + if (needPrivateExponent) { + x = BinToBN(key->data + offset, keyMaterial->xSize); + offset += keyMaterial->xSize; } - BIGNUM *y = BN_bin2bn(buff, keyMaterial->ySize, NULL); + y = BinToBN(key->data + offset, keyMaterial->ySize); offset += keyMaterial->ySize; - if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->pSize) != 0) { - return NULL; - } - BIGNUM *p = BN_bin2bn(buff, keyMaterial->pSize, NULL); + p = BinToBN(key->data + offset, keyMaterial->pSize); offset += keyMaterial->pSize; - if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->qSize) != 0) { - return NULL; - } - BIGNUM *q = BN_bin2bn(buff, keyMaterial->qSize, NULL); + q = BinToBN(key->data + offset, keyMaterial->qSize); offset += keyMaterial->qSize; - if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->gSize) != 0) { - return NULL; - } - BIGNUM *g = BN_bin2bn(buff, keyMaterial->gSize, NULL); - DSA *dsa = DSA_new(); - if (DSA_set0_key(dsa, y, x) != 1 || DSA_set0_pqg(dsa, p, q, g) != 1) { - return NULL; + g = BinToBN(key->data + offset, keyMaterial->gSize); + + DSA *dsa = NULL; + do { + dsa = DSA_new(); + if (dsa == NULL) { + break; + } + + if (DSA_set0_key(dsa, y, x) != 1) { + DSA_free(dsa); + dsa = NULL; + break; + } + + if (DSA_set0_pqg(dsa, p, q, g) != 1) { + DSA_free(dsa); + dsa = NULL; + break; + } + } while (0); + + if (dsa == NULL) { + FreeBN(x); + FreeBN(y); + FreeBN(p); + FreeBN(q); + FreeBN(g); } return dsa; @@ -126,14 +159,19 @@ int32_t OpensslSignDsa( EVP_PKEY *pkey = EVP_PKEY_new(); if (pkey == NULL) { + DSA_free(dsa); + return DSA_FAILED; + } + + if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) { EVP_PKEY_free(pkey); + DSA_free(dsa); return DSA_FAILED; } - EVP_PKEY_assign_DSA(pkey, dsa); EVP_MD_CTX *mctx = EVP_MD_CTX_new(); if (mctx == NULL) { - EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); return DSA_FAILED; } @@ -145,22 +183,22 @@ int32_t OpensslSignDsa( } if (EVP_DigestSignUpdate(mctx, plainText->data, plainText->size) != 1) { - EVP_MD_CTX_free(mctx); EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); return DSA_FAILED; } size_t signLen = signData->size; if (EVP_DigestSignFinal(mctx, signData->data, &signLen) != 1) { - EVP_MD_CTX_free(mctx); EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); return DSA_FAILED; } signData->size = signLen; - EVP_MD_CTX_free(mctx); EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); return DSA_SUCCESS; } @@ -175,14 +213,19 @@ int32_t OpensslVerifyDsa( EVP_PKEY *pkey = EVP_PKEY_new(); if (pkey == NULL) { + DSA_free(dsa); + return DSA_FAILED; + } + + if (EVP_PKEY_assign_DSA(pkey, dsa) != 1) { EVP_PKEY_free(pkey); + DSA_free(dsa); return DSA_FAILED; } - EVP_PKEY_assign_DSA(pkey, dsa); EVP_MD_CTX *mctx = EVP_MD_CTX_new(); if (mctx == NULL) { - EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); return DSA_FAILED; } @@ -194,32 +237,35 @@ int32_t OpensslVerifyDsa( } if (EVP_DigestVerifyUpdate(mctx, plainText->data, plainText->size) != 1) { - EVP_MD_CTX_free(mctx); EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); return DSA_FAILED; } if (EVP_DigestVerifyFinal(mctx, signData->data, signData->size) != 1) { - EVP_MD_CTX_free(mctx); EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); return DSA_FAILED; } - EVP_MD_CTX_free(mctx); EVP_PKEY_free(pkey); + EVP_MD_CTX_free(mctx); return DSA_SUCCESS; } int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey) { - EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&x509Key->data, x509Key->size); + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); if (pkey == NULL) { return DSA_FAILED; } - DSA *dsa = EVP_PKEY_get1_DSA(pkey); + DSA *dsa = EVP_PKEY_get0_DSA(pkey); if (dsa == NULL) { + EVP_PKEY_free(pkey); return DSA_FAILED; } int32_t ySize = BN_num_bytes(DSA_get0_pub_key(dsa)); @@ -227,6 +273,7 @@ int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey) int32_t qSize = BN_num_bytes(DSA_get0_q(dsa)); int32_t gSize = BN_num_bytes(DSA_get0_g(dsa)); if ((ySize <= 0) || (pSize <= 0) || (qSize <= 0) || (gSize <= 0)) { + EVP_PKEY_free(pkey); return DSA_FAILED; } struct KeyMaterialDsa *keyMaterial = (struct KeyMaterialDsa *)publicKey->data; @@ -238,18 +285,26 @@ int32_t X509ToDsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey) keyMaterial->qSize = qSize; keyMaterial->gSize = gSize; - if ((BN_bn2bin(DSA_get0_pub_key(dsa), publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize) == 0) || - (BN_bn2bin(DSA_get0_p(dsa), publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize) == - 0) || - (BN_bn2bin(DSA_get0_q(dsa), - publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize) == 0) || - (BN_bn2bin(DSA_get0_g(dsa), - publicKey->data + sizeof(struct KeyMaterialDsa) + keyMaterial->xSize + ySize + pSize + qSize) == 0)) { - free(publicKey->data); - return DSA_FAILED; - } + int32_t result = DSA_FAILED; + uint32_t offset = sizeof(struct KeyMaterialDsa) + keyMaterial->xSize; + do { + if ((BN_bn2bin(DSA_get0_pub_key(dsa), publicKey->data + offset) == 0)) { + break; + } + if (BN_bn2bin(DSA_get0_p(dsa), publicKey->data + offset + ySize) == 0) { + break; + } + if (BN_bn2bin(DSA_get0_q(dsa), publicKey->data + offset + ySize + pSize) == 0) { + break; + } + if (BN_bn2bin(DSA_get0_g(dsa), publicKey->data + offset + ySize + pSize + qSize) == 0) { + break; + } + result = DSA_SUCCESS; + } while (0); - return DSA_SUCCESS; + EVP_PKEY_free(pkey); + return result; } void DsaGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key) @@ -257,12 +312,14 @@ void DsaGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key) uint8_t *tmp = NULL; int32_t length = i2d_PUBKEY(pkey, &tmp); x509Key->size = length; - x509Key->data = tmp; + if (tmp != NULL) { + (void)memcpy_s(x509Key->data, x509Key->size, tmp, length); + free(tmp); + } } int32_t SaveDsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob *key) { - int32_t ret; uint32_t opensslKeyByteLen = HKS_KEY_BYTES(keySize); if (opensslKeyByteLen < OPENSSL_DSA_MIN_KEY_LEN) { opensslKeyByteLen = OPENSSL_DSA_MIN_KEY_LEN; @@ -285,7 +342,7 @@ int32_t SaveDsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBl const BIGNUM *g = DSA_get0_g(EVP_PKEY_get0_DSA(pkey)); int32_t offset = sizeof(struct KeyMaterialDsa); - ret = BN_bn2bin(x, key->data + offset + (keyMaterial->xSize - BN_num_bytes(x))); + int32_t ret = BN_bn2bin(x, key->data + offset + (keyMaterial->xSize - BN_num_bytes(x))); if (ret <= 0) { return DSA_FAILED; } diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_ecc_mt_test.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_ecc_helper.c similarity index 89% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_ecc_mt_test.c rename to interfaces/innerkits/huks_standard/test/moduletest/src/openssl_ecc_helper.c index 13f138df..71701bdf 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_ecc_mt_test.c +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_ecc_helper.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "hks_openssl_ecc_mt_test.h" +#include "openssl_ecc_helper.h" #include #include @@ -105,29 +105,38 @@ static int32_t EccSaveKeyMaterial(const EC_KEY *eccKey, const uint32_t keyLen, u return ECC_FAILED; } - const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey); - if (ecGroup == NULL) { - return ECC_FAILED; - } + int32_t result = ECC_FAILED; + do { + const EC_GROUP *ecGroup = EC_KEY_get0_group(eccKey); + if (ecGroup == NULL) { + break; + } - if (EC_POINT_get_affine_coordinates_GFp(ecGroup, EC_KEY_get0_public_key(eccKey), pubX, pubY, NULL) <= 0) { - return ECC_FAILED; - } + if (EC_POINT_get_affine_coordinates_GFp(ecGroup, EC_KEY_get0_public_key(eccKey), pubX, pubY, NULL) != 1) { + break; + } - const BIGNUM *priv = EC_KEY_get0_private_key(eccKey); - if (priv == NULL) { - return ECC_FAILED; - } + const BIGNUM *priv = EC_KEY_get0_private_key(eccKey); + if (priv == NULL) { + break; + } - if (TransEccKeyToKeyBlob(keyMaterial, pubX, pubY, priv, rawMaterial) == ECC_FAILED) { - return ECC_FAILED; - } + if (TransEccKeyToKeyBlob(keyMaterial, pubX, pubY, priv, rawMaterial) == ECC_FAILED) { + break; + } + + *outputSize = rawMaterialLen; + + if (memcpy_s(*output, *outputSize, rawMaterial, rawMaterialLen) != 0) { + break; + } - *output = rawMaterial; - *outputSize = rawMaterialLen; + result = ECC_SUCCESS; + } while (0); BN_free(pubX); BN_free(pubY); + free(rawMaterial); return ECC_SUCCESS; } @@ -144,10 +153,12 @@ int32_t ECCGenerateKey(const int keyLen, struct HksBlob *key) } if (EC_KEY_generate_key(eccKey) <= 0) { + EC_KEY_free(eccKey); return ECC_FAILED; } if (EccSaveKeyMaterial(eccKey, keyLen, &key->data, &key->size) != ECC_SUCCESS) { + EC_KEY_free(eccKey); return ECC_FAILED; } @@ -242,7 +253,11 @@ static EC_KEY *EccInitKey(const struct HksBlob *keyBlob, bool sign) if (sign) { BIGNUM *pri = BN_bin2bn(keyPair + sizeof(struct KeyMaterialEcc) + publicXSize + publicYSize, privateSize, NULL); - if (pri == NULL || EC_KEY_set_private_key(eccKey, pri) <= 0) { + if (pri == NULL) { + EC_KEY_free(eccKey); + return NULL; + } + if (EC_KEY_set_private_key(eccKey, pri) != 1) { BN_free(pri); EC_KEY_free(eccKey); return NULL; @@ -268,7 +283,7 @@ static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest, return NULL; } - if (EVP_PKEY_assign_EC_KEY(key, eccKey) <= 0) { + if (EVP_PKEY_assign_EC_KEY(key, eccKey) != 1) { EC_KEY_free(eccKey); EVP_PKEY_free(key); return NULL; @@ -283,14 +298,14 @@ static EVP_MD_CTX *InitEccMdCtx(const struct HksBlob *mainKey, uint32_t digest, if (sign) { int32_t ret = EVP_DigestSignInit(ctx, NULL, md, NULL, key); EVP_PKEY_free(key); - if (ret <= 0) { + if (ret != 1) { EVP_MD_CTX_free(ctx); return NULL; } } else { int ret = EVP_DigestVerifyInit(ctx, NULL, md, NULL, key); EVP_PKEY_free(key); - if (ret <= 0) { + if (ret != 1) { EVP_MD_CTX_free(ctx); return NULL; } @@ -305,18 +320,18 @@ int32_t EcdsaSign(const struct HksBlob *key, int digest, const struct HksBlob *m return ECC_FAILED; } - if (EVP_DigestSignUpdate(ctx, message->data, message->size) <= 0) { + if (EVP_DigestSignUpdate(ctx, message->data, message->size) != 1) { EVP_MD_CTX_free(ctx); return ECC_FAILED; } size_t req = 0; - if (EVP_DigestSignFinal(ctx, NULL, &req) <= 0) { + if (EVP_DigestSignFinal(ctx, NULL, &req) != 1) { EVP_MD_CTX_free(ctx); return ECC_FAILED; } - if (EVP_DigestSignFinal(ctx, signature->data, &req) <= 0) { + if (EVP_DigestSignFinal(ctx, signature->data, &req) != 1) { EVP_MD_CTX_free(ctx); return ECC_FAILED; } @@ -334,12 +349,12 @@ int32_t EcdsaVerify( return ECC_FAILED; } - if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) <= 0) { + if (EVP_DigestVerifyUpdate(ctx, message->data, message->size) != 1) { EVP_MD_CTX_free(ctx); return ECC_FAILED; } - if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) <= 0) { + if (EVP_DigestVerifyFinal(ctx, signature->data, signature->size) != 1) { EVP_MD_CTX_free(ctx); return ECC_FAILED; } @@ -412,8 +427,12 @@ static int32_t EcKeyToPublicKey(EC_KEY *ecKey, struct HksBlob *eccPublicKey) } ret = ECC_SUCCESS; - eccPublicKey->data = keyBuffer; eccPublicKey->size = totalSize; + if (memcpy_s(eccPublicKey->data, eccPublicKey->size, keyBuffer, totalSize) != 0) { + HKS_FREE_PTR(keyBuffer); + break; + } + HKS_FREE_PTR(keyBuffer); } while (0); SELF_FREE_PTR(x, BN_free); @@ -436,14 +455,16 @@ int32_t X509ToHksBlob(const struct HksBlob *x509Key, struct HksBlob *publicKey) EC_KEY *ecKey = EVP_PKEY_get0_EC_KEY(pkey); if (ecKey == NULL) { + EVP_PKEY_free(pkey); return ECC_FAILED; } if (EcKeyToPublicKey(ecKey, publicKey) != ECC_SUCCESS) { + EVP_PKEY_free(pkey); return ECC_FAILED; }; - SELF_FREE_PTR(pkey, EVP_PKEY_free); + EVP_PKEY_free(pkey); return ECC_SUCCESS; } @@ -489,7 +510,19 @@ int32_t HksBlobToX509(const struct HksBlob *key, struct HksBlob *x509Key) uint8_t *tmp = NULL; int32_t length = i2d_PUBKEY(pkey, &tmp); x509Key->size = length; - x509Key->data = tmp; + if (tmp == NULL) { + EVP_PKEY_free(pkey); + return ECC_FAILED; + } + + if (memcpy_s(x509Key->data, x509Key->size, tmp, length) != 0) { + EVP_PKEY_free(pkey); + free(tmp); + return ECC_FAILED; + } + + EVP_PKEY_free(pkey); + free(tmp); return ECC_SUCCESS; } @@ -582,7 +615,9 @@ int32_t EcdhAgreeKey( ret = ECC_SUCCESS; } while (0); - EVP_PKEY_CTX_free(ctx); + if (ctx != NULL) { + EVP_PKEY_CTX_free(ctx); + } if (peerKey != NULL) { EVP_PKEY_free(peerKey); } diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_hmac_mt_test.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_hmac_helper.c similarity index 94% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_hmac_mt_test.c rename to interfaces/innerkits/huks_standard/test/moduletest/src/openssl_hmac_helper.c index c75e739c..8dd44384 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_hmac_mt_test.c +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_hmac_helper.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "hks_openssl_hmac_mt_test.h" +#include "openssl_hmac_helper.h" int32_t HmacGenerateKey(int key_len, struct HksBlob *key) { @@ -24,7 +24,8 @@ int32_t HmacGenerateKey(int key_len, struct HksBlob *key) return HMAC_FAILED; } - if (RAND_bytes(tmpKey, keySizeByte) <= 0) { + if (RAND_bytes(tmpKey, keySizeByte) != 1) { + free(tmpKey); return HMAC_FAILED; } diff --git a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_rsa_test_mt.c b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_rsa_helper.c similarity index 72% rename from interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_rsa_test_mt.c rename to interfaces/innerkits/huks_standard/test/moduletest/src/openssl_rsa_helper.c index 010d1afa..d607bec2 100755 --- a/interfaces/innerkits/huks_standard/test/moduletest/src/hks_openssl_rsa_test_mt.c +++ b/interfaces/innerkits/huks_standard/test/moduletest/src/openssl_rsa_helper.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "hks_openssl_rsa_test_mt.h" +#include "openssl_rsa_helper.h" #include #include @@ -31,51 +31,57 @@ void SaveRsaKeyToHksBlob(EVP_PKEY *pkey, const uint32_t keySize, struct HksBlob keyMaterial->eSize = keyByteLen; keyMaterial->dSize = keyByteLen; - int dataLen; uint8_t tmpBuff[keyByteLen]; memset_s(tmpBuff, keyByteLen, 0x00, keyByteLen); uint32_t offset = sizeof(*keyMaterial); - dataLen = BN_bn2bin(RSA_get0_n(EVP_PKEY_get0_RSA(pkey)), tmpBuff); - if (dataLen > 0) { - (void)memcpy_s(key->data + offset + keyByteLen - dataLen, keyMaterial->nSize, tmpBuff, dataLen); + if (BN_bn2binpad(RSA_get0_n(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) { + (void)memcpy_s(key->data + offset, keyMaterial->nSize, tmpBuff, keyMaterial->nSize); } offset += keyMaterial->nSize; - dataLen = BN_bn2bin(RSA_get0_e(EVP_PKEY_get0_RSA(pkey)), tmpBuff); - if (dataLen > 0) { - (void)memcpy_s(key->data + offset + keyByteLen - dataLen, keyMaterial->eSize, tmpBuff, dataLen); + if (BN_bn2binpad(RSA_get0_e(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) { + (void)memcpy_s(key->data + offset, keyMaterial->eSize, tmpBuff, keyMaterial->eSize); } offset += keyMaterial->eSize; - dataLen = BN_bn2bin(RSA_get0_d(EVP_PKEY_get0_RSA(pkey)), tmpBuff); - if (dataLen > 0) { - (void)memcpy_s(key->data + offset + keyByteLen - dataLen, keyMaterial->dSize, tmpBuff, dataLen); + if (BN_bn2binpad(RSA_get0_d(EVP_PKEY_get0_RSA(pkey)), tmpBuff, keyByteLen) > 0) { + (void)memcpy_s(key->data + offset, keyMaterial->dSize, tmpBuff, keyMaterial->dSize); } + key->size = sizeof(struct KeyMaterialRsa) + keyMaterial->nSize + keyMaterial->eSize + keyMaterial->dSize; } EVP_PKEY *GenerateRSAKey(const uint32_t keySize) { - EVP_PKEY *pkey = EVP_PKEY_new(); - if (pkey == NULL) { + BIGNUM *bne = BN_new(); + if (bne == NULL) { return NULL; } + BN_set_word(bne, RSA_F4); + RSA *rsa = RSA_new(); if (rsa == NULL) { - EVP_PKEY_free(pkey); + BN_free(bne); return NULL; } - BIGNUM *bne = BN_new(); - BN_set_word(bne, RSA_F4); - if (bne == NULL) { + + if (RSA_generate_key_ex(rsa, keySize, bne, NULL) != 1) { RSA_free(rsa); - EVP_PKEY_free(pkey); + BN_free(bne); return NULL; } - RSA_generate_key_ex(rsa, keySize, bne, NULL); BN_free(bne); - EVP_PKEY_assign_RSA(pkey, rsa); + EVP_PKEY *pkey = EVP_PKEY_new(); + if (pkey == NULL) { + return NULL; + } + + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { + EVP_PKEY_free(pkey); + RSA_free(rsa); + return NULL; + } return pkey; } @@ -85,23 +91,30 @@ void OpensslGetx509PubKey(EVP_PKEY *pkey, struct HksBlob *x509Key) uint8_t *tmp = NULL; int32_t length = i2d_PUBKEY(pkey, &tmp); x509Key->size = length; - x509Key->data = tmp; + if (tmp != NULL) { + (void)memcpy_s(x509Key->data, x509Key->size, tmp, length); + free(tmp); + } } int32_t X509ToRsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey) { - EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&x509Key->data, x509Key->size); + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); if (pkey == NULL) { return RSA_FAILED; } - RSA *rsa = EVP_PKEY_get1_RSA(pkey); + RSA *rsa = EVP_PKEY_get0_RSA(pkey); if (rsa == NULL) { + EVP_PKEY_free(pkey); return RSA_FAILED; } int32_t nSize = BN_num_bytes(RSA_get0_n(rsa)); int32_t eSize = BN_num_bytes(RSA_get0_e(rsa)); if ((nSize <= 0) || (eSize <= 0)) { + EVP_PKEY_free(pkey); return RSA_FAILED; } @@ -112,10 +125,10 @@ int32_t X509ToRsaPublicKey(struct HksBlob *x509Key, struct HksBlob *publicKey) pubKeyInfo->eOrYSize = eSize; if ((BN_bn2bin(RSA_get0_n(rsa), publicKey->data + sizeof(struct HksPubKeyInfo)) == 0) || (BN_bn2bin(RSA_get0_e(rsa), publicKey->data + sizeof(struct HksPubKeyInfo) + nSize) == 0)) { - free(publicKey->data); + EVP_PKEY_free(pkey); return RSA_FAILED; } - + EVP_PKEY_free(pkey); return RSA_SUCCESS; } @@ -124,30 +137,45 @@ static RSA *InitRsa(struct HksBlob *key, const bool needPrivateExponent) const struct KeyMaterialRsa *keyMaterial = (struct KeyMaterialRsa *)(key->data); uint8_t buff[HKS_KEY_BYTES(keyMaterial->keySize)]; + BIGNUM *n = NULL; + BIGNUM *e = NULL; + BIGNUM *d = NULL; + uint32_t offset = sizeof(*keyMaterial); - if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->nSize) != 0) { - return NULL; + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->nSize) == 0) { + n = BN_bin2bn(buff, keyMaterial->nSize, NULL); } - - BIGNUM *n = BN_bin2bn(buff, keyMaterial->nSize, NULL); offset += keyMaterial->nSize; - if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->eSize) != 0) { - return NULL; - } - BIGNUM *e = BN_bin2bn(buff, keyMaterial->eSize, NULL); + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->eSize) == 0) { + e = BN_bin2bn(buff, keyMaterial->eSize, NULL); + } offset += keyMaterial->eSize; - BIGNUM *d = NULL; - if (needPrivateExponent) { - (void)memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->dSize); - d = BN_bin2bn(buff, keyMaterial->dSize, NULL); + if (needPrivateExponent) { + if (memcpy_s(buff, sizeof(buff), key->data + offset, keyMaterial->dSize) == 0) { + d = BN_bin2bn(buff, keyMaterial->dSize, NULL); + } } RSA *rsa = RSA_new(); - int32_t ret = RSA_set0_key(rsa, n, e, d); - if (ret != 1) { - return NULL; + if (rsa != NULL) { + if (RSA_set0_key(rsa, n, e, d) != 1) { + RSA_free(rsa); + rsa = NULL; + } + } + + if (rsa == NULL) { + if (n != NULL) { + BN_free(n); + } + if (e != NULL) { + BN_free(e); + } + if (d != NULL) { + BN_free(d); + } } return rsa; @@ -172,6 +200,7 @@ static const EVP_MD *GetOpensslDigestType(enum HksKeyDigest digestType) return NULL; } } + int32_t EncryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct HksBlob *key, int padding, enum HksKeyDigest digestType) { @@ -181,40 +210,41 @@ int32_t EncryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct } EVP_PKEY *pkey = EVP_PKEY_new(); if (pkey == NULL) { + return RSA_FAILED; + } + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { EVP_PKEY_free(pkey); + RSA_free(rsa); return RSA_FAILED; } - EVP_PKEY_assign_RSA(pkey, rsa); EVP_PKEY_CTX *ectx = EVP_PKEY_CTX_new(pkey, NULL); if (ectx == NULL) { EVP_PKEY_free(pkey); return RSA_FAILED; } - EVP_PKEY_encrypt_init(ectx); - - EVP_PKEY_CTX_set_rsa_padding(ectx, padding); - + if ((EVP_PKEY_encrypt_init(ectx) != 1) || (EVP_PKEY_CTX_set_rsa_padding(ectx, padding) != 1)) { + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } if (padding == RSA_PKCS1_OAEP_PADDING) { const EVP_MD *md = GetOpensslDigestType(digestType); - if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) <= 0) || - (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) <= 0)) { + if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) != 1) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) != 1)) { EVP_PKEY_CTX_free(ectx); EVP_PKEY_free(pkey); return RSA_FAILED; } } size_t outLen = outData->size; - int result = EVP_PKEY_encrypt(ectx, outData->data, &outLen, inData->data, inData->size); - if (result != 1) { + if (EVP_PKEY_encrypt(ectx, outData->data, &outLen, inData->data, inData->size) != 1) { EVP_PKEY_CTX_free(ectx); EVP_PKEY_free(pkey); return RSA_FAILED; } outData->size = outLen; - EVP_PKEY_CTX_free(ectx); EVP_PKEY_free(pkey); - return RSA_SUCCESS; } @@ -227,31 +257,35 @@ int32_t DecryptRSA(const struct HksBlob *inData, struct HksBlob *outData, struct } EVP_PKEY *pkey = EVP_PKEY_new(); if (pkey == NULL) { + RSA_free(rsa); + return RSA_FAILED; + } + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { EVP_PKEY_free(pkey); + RSA_free(rsa); return RSA_FAILED; } - EVP_PKEY_assign_RSA(pkey, rsa); EVP_PKEY_CTX *ectx = EVP_PKEY_CTX_new(pkey, NULL); if (ectx == NULL) { EVP_PKEY_free(pkey); return RSA_FAILED; } - EVP_PKEY_decrypt_init(ectx); - - EVP_PKEY_CTX_set_rsa_padding(ectx, padding); - + if ((EVP_PKEY_decrypt_init(ectx) != 1) || (EVP_PKEY_CTX_set_rsa_padding(ectx, padding) != 1)) { + EVP_PKEY_CTX_free(ectx); + EVP_PKEY_free(pkey); + return RSA_FAILED; + } if (padding == RSA_PKCS1_OAEP_PADDING) { const EVP_MD *md = GetOpensslDigestType(digestType); - if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) <= 0) || - (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) <= 0)) { + if ((md == NULL) || (EVP_PKEY_CTX_set_rsa_oaep_md(ectx, md) != 1) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ectx, md) != 1)) { EVP_PKEY_CTX_free(ectx); EVP_PKEY_free(pkey); return RSA_FAILED; } } size_t outLen = outData->size; - int result = EVP_PKEY_decrypt(ectx, outData->data, &outLen, inData->data, inData->size); - if (result != 1) { + if (EVP_PKEY_decrypt(ectx, outData->data, &outLen, inData->data, inData->size) != 1) { EVP_PKEY_CTX_free(ectx); EVP_PKEY_free(pkey); return RSA_FAILED; @@ -274,14 +308,19 @@ int32_t OpensslSignRsa(const struct HksBlob *plainText, struct HksBlob *signData EVP_PKEY *pkey = EVP_PKEY_new(); if (pkey == NULL) { + RSA_free(rsa); + return RSA_FAILED; + } + + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { EVP_PKEY_free(pkey); + RSA_free(rsa); return RSA_FAILED; } - EVP_PKEY_assign_RSA(pkey, rsa); EVP_MD_CTX *mctx = EVP_MD_CTX_new(); if (mctx == NULL) { - EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); return RSA_FAILED; } @@ -293,9 +332,9 @@ int32_t OpensslSignRsa(const struct HksBlob *plainText, struct HksBlob *signData } if (padding == RSA_PKCS1_PSS_PADDING) { - if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1 && - EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_MD_CTX_pkey_ctx(mctx), EVP_MD_size(md))) { + if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1) { EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); return RSA_FAILED; } } @@ -330,16 +369,19 @@ int32_t OpensslVerifyRsa(const struct HksBlob *plainText, struct HksBlob *signDa } EVP_PKEY *pkey = EVP_PKEY_new(); if (pkey == NULL) { + RSA_free(rsa); + return RSA_FAILED; + } + if (EVP_PKEY_assign_RSA(pkey, rsa) != 1) { EVP_PKEY_free(pkey); + RSA_free(rsa); return RSA_FAILED; } - EVP_PKEY_assign_RSA(pkey, rsa); EVP_MD_CTX *mctx = EVP_MD_CTX_new(); if (mctx == NULL) { - EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); return RSA_FAILED; } - const EVP_MD *md = GetOpensslDigestType(digestType); if (EVP_DigestVerifyInit(mctx, NULL, md, NULL, pkey) != 1) { EVP_MD_CTX_free(mctx); @@ -348,9 +390,9 @@ int32_t OpensslVerifyRsa(const struct HksBlob *plainText, struct HksBlob *signDa } if (padding == RSA_PKCS1_PSS_PADDING) { - if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1 && - EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_MD_CTX_pkey_ctx(mctx), EVP_MD_size(md))) { + if (EVP_PKEY_CTX_set_rsa_padding(EVP_MD_CTX_pkey_ctx(mctx), padding) != 1) { EVP_MD_CTX_free(mctx); + EVP_PKEY_free(pkey); return RSA_FAILED; } } diff --git a/ohos.build b/ohos.build index f036d2dd..ee81bf84 100755 --- a/ohos.build +++ b/ohos.build @@ -26,7 +26,8 @@ "test_list": [ "//base/security/huks:huks_sdk_test", "//base/security/huks/services/huks_standard/huks_service/main/test/unittest:huks_multithread_test", - "//base/security/huks/interfaces/innerkits/huks_standard/test/moduletest:huks_mt_test" + "//base/security/huks/interfaces/innerkits/huks_standard/test/moduletest:huks_mt_test", + "//base/security/huks/test/stability:huks_stability_test" ] } } diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c b/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c index 55f3b02e..c133c6b9 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c @@ -87,6 +87,8 @@ static int32_t RsaToX509PublicKey(const struct HksBlob *mod, const struct HksBlo HKS_LOG_E("RSA_set0_key error %s", ERR_reason_error_string(ERR_get_error())); break; } + rsaN = NULL; + rsaE = NULL; pkey = EVP_PKEY_new(); if (pkey == NULL) { HKS_LOG_E("pkey is null"); @@ -179,8 +181,6 @@ static int32_t EccToX509PublicKey( break; } - /* ecKey need to be set to null to prevent Double-Free */ - ecKey = NULL; ret = EvpKeyToX509Format(pkey, x509Key); } while (0); @@ -614,7 +614,8 @@ static int32_t X509PublicKeyToDh(EVP_PKEY *pkey, struct HksBlob *dhPublicKey) const BIGNUM *pubKey = DH_get0_pub_key(dh); uint32_t pubKeySize = BN_num_bytes(pubKey); - uint8_t *keyBuffer = HksMalloc(sizeof(struct KeyMaterialDh) + pubKeySize); + uint32_t totalSize = sizeof(struct KeyMaterialDh) + pubKeySize; + uint8_t *keyBuffer = HksMalloc(totalSize); if (keyBuffer == NULL) { HKS_LOG_E("alloc keyBuffer failed"); return HKS_ERROR_MALLOC_FAIL; @@ -628,7 +629,7 @@ static int32_t X509PublicKeyToDh(EVP_PKEY *pkey, struct HksBlob *dhPublicKey) BN_bn2bin(pubKey, keyBuffer + sizeof(struct KeyMaterialDh)); - dhPublicKey->size = pubKeySize; + dhPublicKey->size = totalSize; dhPublicKey->data = keyBuffer; return HKS_SUCCESS; @@ -642,7 +643,9 @@ int32_t TranslateFromX509PublicKey(const struct HksBlob *x509Key, struct HksBlob return HKS_ERROR_INVALID_ARGUMENT; } - EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&x509Key->data, x509Key->size); + uint8_t *data = x509Key->data; + + EVP_PKEY *pkey = d2i_PUBKEY(NULL, (const unsigned char **)&data, x509Key->size); if (pkey == NULL) { return HKS_ERROR_INVALID_ARGUMENT; } diff --git a/services/huks_standard/huks_service/main/core/src/hks_storage.c b/services/huks_standard/huks_service/main/core/src/hks_storage.c index 6e2a6bd2..20b719fe 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_storage.c +++ b/services/huks_standard/huks_service/main/core/src/hks_storage.c @@ -283,6 +283,71 @@ static int32_t MakeDirIfNotExist(const char *path) return HKS_SUCCESS; } +static int32_t HksStorageWriteFile( + const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len) +{ +#ifdef HKS_SUPPORT_THREAD + char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; + int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get full path failed, ret = %d.", ret); + return ret; + } + + HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); + HksStorageFileLockWrite(lock); + ret = HksFileWrite(path, fileName, offset, buf, len); + HksStorageFileUnlockWrite(lock); + HksStorageFileLockRelease(lock); + return ret; +#else + return HksFileWrite(path, fileName, offset, buf, len); +#endif +} + +static uint32_t HksStorageReadFile( + const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len) +{ +#ifdef HKS_SUPPORT_THREAD + char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; + int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get full path failed, ret = %d.", ret); + return 0; + } + + HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); + HksStorageFileLockRead(lock); + uint32_t size = HksFileRead(path, fileName, offset, buf, len); + HksStorageFileUnlockRead(lock); + HksStorageFileLockRelease(lock); +#else + uint32_t size = HksFileRead(path, fileName, offset, buf, len); +#endif + return size; +} + +static int32_t HksStorageRemoveFile(const char *path, const char *fileName) +{ +#ifdef HKS_SUPPORT_THREAD + char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; + int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN); + if (ret != HKS_SUCCESS) { + HKS_LOG_E("get full path failed, ret = %d.", ret); + return ret; + } + + HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); + HksStorageFileLockWrite(lock); + ret = HksFileRemove(path, fileName); + HksStorageFileUnlockWrite(lock); + HksStorageFileLockRelease(lock); +#else + int32_t ret = HksFileRemove(path, fileName); +#endif + return ret; +} + #ifdef SUPPORT_STORAGE_BACKUP static int32_t GetBakFullPath(const char *path, const char *processName, const char *storeName, struct HksStoreFileInfo *fileInfo) @@ -329,7 +394,7 @@ static int32_t CopyKeyBlobFromSrc(const char *srcPath, const char *srcFileName, int32_t ret; do { - size = HksFileRead(srcPath, srcFileName, 0, buffer, size); + size = HksStorageReadFile(srcPath, srcFileName, 0, buffer, size); if (size == 0) { HKS_LOG_E("read file failed, ret = %u.", size); ret = HKS_ERROR_READ_FILE_FAIL; @@ -342,7 +407,7 @@ static int32_t CopyKeyBlobFromSrc(const char *srcPath, const char *srcFileName, break; } - ret = HksFileWrite(destPath, destFileName, 0, buffer, size); + ret = HksStorageWriteFile(destPath, destFileName, 0, buffer, size); if (ret != HKS_SUCCESS) { HKS_LOG_E("file write destPath failed, ret = %d.", ret); break; @@ -394,22 +459,7 @@ static int32_t GetKeyBlobFromFile(const char *path, const char *fileName, struct return HKS_ERROR_INSUFFICIENT_DATA; } -#ifdef HKS_SUPPORT_THREAD - char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; - int32_t ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("get full path failed, ret = %d.", ret); - return ret; - } - - HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); - HksStorageFileLockRead(lock); - size = HksFileRead(path, fileName, 0, keyBlob->data, keyBlob->size); - HksStorageFileUnlockRead(lock); - HksStorageFileLockRelease(lock); -#else - size = HksFileRead(path, fileName, 0, keyBlob->data, keyBlob->size); -#endif + size = HksStorageReadFile(path, fileName, 0, keyBlob->data, keyBlob->size); if (size == 0) { HKS_LOG_E("file read failed, ret = %u.", size); return HKS_ERROR_READ_FILE_FAIL; @@ -434,23 +484,7 @@ static int32_t SaveKeyBlob(const char *processPath, const char *path, const char return ret; } -#ifdef HKS_SUPPORT_THREAD - char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; - ret = HksGetFileName(path, fileName, fullPath, HKS_MAX_FILE_NAME_LEN); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("get full path failed, ret = %d.", ret); - return ret; - } - - HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); - HksStorageFileLockWrite(lock); - ret = HksFileWrite(path, fileName, 0, keyBlob->data, keyBlob->size); - HksStorageFileUnlockWrite(lock); - HksStorageFileLockRelease(lock); - return ret; -#else - return HksFileWrite(path, fileName, 0, keyBlob->data, keyBlob->size); -#endif + return HksStorageWriteFile(path, fileName, 0, keyBlob->data, keyBlob->size); } static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo) @@ -461,22 +495,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo) return HKS_ERROR_NOT_EXIST; } -#ifdef HKS_SUPPORT_THREAD - char fullPath[HKS_MAX_FILE_NAME_LEN] = {0}; - int32_t ret = HksGetFileName(fileInfo->mainPath.path, fileInfo->mainPath.fileName, fullPath, HKS_MAX_FILE_NAME_LEN); - if (ret != HKS_SUCCESS) { - HKS_LOG_E("get full path failed, ret = %d.", ret); - return ret; - } - - HksStorageFileLock *lock = HksStorageFileLockCreate(fullPath); - HksStorageFileLockWrite(lock); - ret = HksFileRemove(fileInfo->mainPath.path, fileInfo->mainPath.fileName); - HksStorageFileUnlockWrite(lock); - HksStorageFileLockRelease(lock); -#else - int32_t ret = HksFileRemove(fileInfo->mainPath.path, fileInfo->mainPath.fileName); -#endif + int32_t ret = HksStorageRemoveFile(fileInfo->mainPath.path, fileInfo->mainPath.fileName); if (ret != HKS_SUCCESS) { HKS_LOG_E("delete key remove file failed, ret = %d.", ret); return ret; @@ -489,7 +508,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo) int32_t ret = HKS_SUCCESS; if (isMainFileExist == HKS_SUCCESS) { - ret = HksFileRemove(fileInfo->mainPath.path, fileInfo->mainPath.fileName); + ret = HksStorageRemoveFile(fileInfo->mainPath.path, fileInfo->mainPath.fileName); if (ret != HKS_SUCCESS) { HKS_LOG_E("delete key remove file failed, ret = %d.", ret); return ret; @@ -497,7 +516,7 @@ static int32_t DeleteKeyBlob(const struct HksStoreFileInfo *fileInfo) } if (isBakFileExist == HKS_SUCCESS) { - ret = HksFileRemove(fileInfo->bakPath.path, fileInfo->bakPath.fileName); + ret = HksStorageRemoveFile(fileInfo->bakPath.path, fileInfo->bakPath.fileName); if (ret != HKS_SUCCESS) { HKS_LOG_E("delete key remove bakfile failed, ret = %d.", ret); return ret; diff --git a/services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp b/services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp index 27ddbf21..25e860f4 100755 --- a/services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp +++ b/services/huks_standard/huks_service/main/os_dependency/sa/hks_sa.cpp @@ -251,6 +251,6 @@ void HksService::OnStop() runningState_ = STATE_NOT_START; registerToService_ = false; } -} // UniversalKeystore +} // Hks } // Security } // OHOS diff --git a/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c b/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c index cfbdbf18..1af2274a 100755 --- a/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c +++ b/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service.c @@ -45,7 +45,7 @@ static BOOL MessageHandle(Service *service, Request *request) static TaskConfig GetTaskConfig(Service *service) { (void)service; - TaskConfig config = {LEVEL_HIGH, PRI_NORMAL, STACK_SIZE, QUEUE_SIZE, SINGLE_TASK}; + TaskConfig config = { LEVEL_HIGH, PRI_NORMAL, STACK_SIZE, QUEUE_SIZE, SINGLE_TASK }; return config; } @@ -54,7 +54,7 @@ static HksMgrService g_hksMgrService = { .Initialize = Initialize, .MessageHandle = MessageHandle, .GetTaskConfig = GetTaskConfig, - .identity = {-1, -1, NULL} + .identity = { -1, -1, NULL } }; static void Init(void) diff --git a/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c b/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c index 04d32219..7ae1800b 100755 --- a/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c +++ b/services/huks_standard/huks_service/main/os_dependency/sa/sa_mgr/hks_samgr_service_feature.c @@ -30,7 +30,7 @@ static HksMgrFeature g_hksMgrFeature = { SERVER_IPROXY_IMPL_BEGIN, .Invoke = Invoke, IPROXY_END, - .identity = {-1, -1, NULL}, + .identity = { -1, -1, NULL }, }; static const char *FEATURE_GetName(Feature *feature) { diff --git a/test/stability/BUILD.gn b/test/stability/BUILD.gn new file mode 100755 index 00000000..cd9aee1f --- /dev/null +++ b/test/stability/BUILD.gn @@ -0,0 +1,52 @@ +# Copyright (C) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//base/security/huks/huks.gni") +import("//build/ohos.gni") +import("//build/test.gni") + +module_output_path = "huks_standard/huks_standard_test" + +ohos_moduletest("huks_stability_test") { + module_out_path = module_output_path + testonly = true + sources = [ + "src/api_pressure_test.cpp", + "src/pressure_test.cpp", + ] + + defines = [ + "L2_STANDARD", + "_HARDWARE_ROOT_KEY_", + "_HUKS_LOG_ENABLE_", + ] + + if (use_crypto_lib == "openssl") { + defines += [ "_USE_OPENSSL_" ] + } + if (use_crypto_lib == "mbedtls") { + defines += [ "_USE_MBEDTLS_" ] + } + + include_dirs = [ + "//utils/native/base/include", + "//base/security/huks/interfaces/innerkits/huks_standard/main/include", + "//base/security/huks/frameworks/huks_standard/main/common/include", + ] + + deps = [ + "//base/security/huks/interfaces/innerkits/huks_standard/main:libhukssdk", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + ] +} diff --git a/test/stability/src/api_pressure_test.cpp b/test/stability/src/api_pressure_test.cpp new file mode 100755 index 00000000..154c7775 --- /dev/null +++ b/test/stability/src/api_pressure_test.cpp @@ -0,0 +1,1509 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include "securec.h" + +#include + +#include "hks_api.h" +#include "hks_config.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char GENERATE_KEY[] = "This is for generate key"; +const char IMPORT_KEY[] = "This is for import key"; +const uint32_t TEST_HOURS = 6; +const uint32_t DSA_KEY_SIZE = 1024; +const uint32_t THREADS_NUM = 15; +const uint32_t RANDOM_KEY_SIZE = 512; +const uint32_t MAX_SDK_VERSION_SIZE = 64; +const uint32_t DERIVE_KEY_SIZE = 64; +const uint32_t IV_SIZE = 16; +const uint32_t AAD_SIZE = 16; +const uint32_t RSA_MESSAGE_SIZE = 6; +const uint32_t AES_MESSAGE_SIZE = 16; +const uint32_t COMPLEMENT_LEN = 16; +const uint32_t KEY_PARAMSET_SIZE = 1024; +const uint32_t MESSAGE_SIZE = 64; +const uint32_t TEST_KEY_SIZE = 4096; +const uint32_t CIPHER_SIZE = 4096; +const uint32_t MAX_STRING_LENTH = 513; + +static const struct HksParam CIPHER_PARAMS[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, +}; + +const struct HksParam g_PARAM_ALGORITHM_AES = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }; +const struct HksParam g_PARAM_ALGORITHM_RSA = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA }; +const struct HksParam g_PARAM_ALGORITHM_ECC = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }; +#ifndef _USE_MBEDTLS_ +const struct HksParam g_PARAM_ALGORITHM_DSA = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA }; +#endif +#ifdef HKS_SUPPORT_DH_C +const struct HksParam g_PARAM_ALGORITHM_DH = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH }; +#endif +const struct HksParam g_PARAM_ALGORITHM_ECDH = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }; + +const struct HksParam g_PARAM_KEYSIZE_AES_128 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }; +const struct HksParam g_PARAM_KEYSIZE_AES_192 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 }; +const struct HksParam g_PARAM_KEYSIZE_AES_256 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_512 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_768 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_1024 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_2048 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_3072 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 }; +const struct HksParam g_PARAM_KEYSIZE_RSA_4096 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 }; +const struct HksParam g_PARAM_KEYSIZE_ECC_224 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }; +const struct HksParam g_PARAM_KEYSIZE_ECC_256 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 }; +const struct HksParam g_PARAM_KEYSIZE_ECC_384 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 }; +const struct HksParam g_PARAM_KEYSIZE_ECC_521 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 }; +#ifdef HKS_SUPPORT_DH_C +const struct HksParam g_PARAM_KEYSIZE_DH_2048 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 }; +const struct HksParam g_PARAM_KEYSIZE_DH_3072 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 }; +const struct HksParam g_PARAM_KEYSIZE_DH_4096 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 }; +#endif +const struct HksParam g_PARAM_KEYSIZE_DSA_1024 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DSA_KEY_SIZE }; + +const struct HksParam g_PARAM_PADDING_NONE = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE }; +const struct HksParam g_PARAM_PADDING_OAEP = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP }; +const struct HksParam g_PARAM_PADDING_PKCS1_V1_5 = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 }; +const struct HksParam g_PARAM_PADDING_PKCS7 = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }; +const struct HksParam g_PARAM_PADDING_PSS = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS }; + +const struct HksParam g_PARAM_MODE_CBC = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }; +const struct HksParam g_PARAM_MODE_CTR = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR }; +const struct HksParam g_PARAM_MODE_ECB = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB }; +const struct HksParam g_PARAM_MODE_GCM = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM }; + +const struct HksParam g_PARAM_DIGEST_NONE = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }; +const struct HksParam g_PARAM_DIGEST_MD5 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 }; +const struct HksParam g_PARAM_DIGEST_SHA1 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }; +const struct HksParam g_PARAM_DIGEST_SHA224 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 }; +const struct HksParam g_PARAM_DIGEST_SHA256 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }; +const struct HksParam g_PARAM_DIGEST_SHA384 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 }; +const struct HksParam g_PARAM_DIGEST_SHA512 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 }; + +inline uint32_t GetRandom() +{ + std::random_device rd; + return rd(); +} + +void AESModeRandForCiper(struct HksParamSet *paramInSet) +{ + struct HksParam tagIv; + uint8_t iv[IV_SIZE] = {0}; + const struct HksParam *paramMode[] = { + &g_PARAM_MODE_CBC, + &g_PARAM_MODE_CTR, + &g_PARAM_MODE_ECB, + &g_PARAM_MODE_GCM, + }; + const struct HksParam *paramPadding[] = { + &g_PARAM_PADDING_NONE, + &g_PARAM_PADDING_PKCS7, + }; + const uint32_t countOfMode = sizeof(paramMode) / sizeof(struct HksParam *); + const uint32_t countOfPadding = sizeof(paramPadding) / sizeof(struct HksParam *); + const uint32_t indexOfMode = GetRandom() % countOfMode; + HksAddParams(paramInSet, paramMode[indexOfMode], 1); + if (paramMode[indexOfMode]->uint32Param == HKS_MODE_CBC) { + tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + HksAddParams(paramInSet, paramPadding[GetRandom() % countOfPadding], 1); + } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_CTR) { + HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1); + tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_ECB) { + tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); +#ifndef _USE_MBEDTLS_ + HksAddParams(paramInSet, paramPadding[GetRandom() % countOfPadding], 1); +#else + HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1); +#endif + } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_GCM) { + HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1); + uint8_t aadData[AAD_SIZE] = { 'a', 'a', 'd' }; + struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } }; + HksAddParams(paramInSet, &aad, 1); + tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + } +} + +void ParamForAESCipher(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_AES_128, + &g_PARAM_KEYSIZE_AES_192, + &g_PARAM_KEYSIZE_AES_256, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); + AESModeRandForCiper(paramInSet); +} + +void RSAKeySizeRand(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_RSA_512, + &g_PARAM_KEYSIZE_RSA_768, + &g_PARAM_KEYSIZE_RSA_1024, + &g_PARAM_KEYSIZE_RSA_2048, + &g_PARAM_KEYSIZE_RSA_3072, + &g_PARAM_KEYSIZE_RSA_4096, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); +} + +void RSAKeySizeWithout512(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_RSA_768, + &g_PARAM_KEYSIZE_RSA_1024, + &g_PARAM_KEYSIZE_RSA_2048, + &g_PARAM_KEYSIZE_RSA_3072, + &g_PARAM_KEYSIZE_RSA_4096, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); +} + +void RSAKeySizeWithout768(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_RSA_1024, + &g_PARAM_KEYSIZE_RSA_2048, + &g_PARAM_KEYSIZE_RSA_3072, + &g_PARAM_KEYSIZE_RSA_4096, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); +} + +void OaepSha512KeySize(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_RSA_2048, + &g_PARAM_KEYSIZE_RSA_3072, + &g_PARAM_KEYSIZE_RSA_4096, + }; + const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1); +} + +void ParamForRSACipher(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramPadding[] = { +#ifndef _USE_MBEDTLS_ + &g_PARAM_PADDING_NONE, +#endif + &g_PARAM_PADDING_PKCS1_V1_5, + &g_PARAM_PADDING_OAEP, + }; + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_NONE, + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t countOfPadding = sizeof(paramPadding) / sizeof(struct HksParam *); + const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *); + const uint32_t indexOfPadding = GetRandom() % countOfPadding; + HksAddParams(paramInSet, paramPadding[indexOfPadding], 1); + if ((paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_NONE) || + (paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_PKCS1_V1_5)) { + RSAKeySizeRand(paramInSet); + HksAddParams(paramInSet, &g_PARAM_DIGEST_NONE, 1); + } else if (paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_OAEP) { + const uint32_t indexOfDigest = GetRandom() % countOfDigest; + HksAddParams(paramInSet, paramDigest[indexOfDigest], 1); + if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA256) { + RSAKeySizeWithout512(paramInSet); + } else if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA384) { + RSAKeySizeWithout768(paramInSet); + } else if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA512) { + OaepSha512KeySize(paramInSet); + } else { + RSAKeySizeRand(paramInSet); + } + } +} + +void ParamForCipher(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramAlgorithm[] = { + &g_PARAM_ALGORITHM_AES, + &g_PARAM_ALGORITHM_RSA, + }; + const uint32_t count = sizeof(paramAlgorithm) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramAlgorithm[index], 1); + if (paramAlgorithm[index]->uint32Param == HKS_ALG_AES) { + ParamForAESCipher(paramInSet); + } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_RSA) { + HksAddParams(paramInSet, &g_PARAM_MODE_ECB, 1); + ParamForRSACipher(paramInSet); + } +} + +void ShaForPkcs1(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_NONE, + &g_PARAM_DIGEST_MD5, + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t count = sizeof(paramDigest) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramDigest[index], 1); + if ((paramDigest[index]->uint32Param == HKS_DIGEST_SHA384) || + (paramDigest[index]->uint32Param == HKS_DIGEST_SHA512)) { + RSAKeySizeWithout512(paramInSet); + } else { + RSAKeySizeRand(paramInSet); + } +} + +void ShaForPss(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_NONE, + &g_PARAM_DIGEST_MD5, + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t count = sizeof(paramDigest) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramDigest[index], 1); + if (paramDigest[index]->uint32Param == HKS_DIGEST_SHA384) { +#ifndef _USE_MBEDTLS_ + RSAKeySizeRand(paramInSet); +#else + RSAKeySizeWithout512(paramInSet); +#endif + } else if (paramDigest[index]->uint32Param == HKS_DIGEST_SHA512) { +#ifndef _USE_MBEDTLS_ + RSAKeySizeWithout512(paramInSet); +#else + RSAKeySizeWithout768(paramInSet); +#endif + } else { + RSAKeySizeRand(paramInSet); + } +} + +void ParamForRSASign(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramPadding[] = { + &g_PARAM_PADDING_PKCS1_V1_5, + &g_PARAM_PADDING_PSS, + }; + const uint32_t count = sizeof(paramPadding) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramPadding[index], 1); + if (paramPadding[index]->uint32Param == HKS_PADDING_PKCS1_V1_5) { + ShaForPkcs1(paramInSet); + } else if (paramPadding[index]->uint32Param == HKS_PADDING_PSS) { + ShaForPss(paramInSet); + } +} + +void ParamForECCSign(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_ECC_224, + &g_PARAM_KEYSIZE_ECC_256, + &g_PARAM_KEYSIZE_ECC_384, + &g_PARAM_KEYSIZE_ECC_521, + }; + const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramKeySize[GetRandom() % countOfKeySize], 1); + + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_NONE, + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramDigest[GetRandom() % countOfDigest], 1); +} + +void ParamForDSASign(struct HksParamSet *paramInSet) +{ + HksAddParams(paramInSet, &g_PARAM_PADDING_PKCS1_V1_5, 1); + HksAddParams(paramInSet, &g_PARAM_KEYSIZE_DSA_1024, 1); + const struct HksParam *paramDigest[] = { + &g_PARAM_DIGEST_SHA1, + &g_PARAM_DIGEST_SHA224, + &g_PARAM_DIGEST_SHA256, + &g_PARAM_DIGEST_SHA384, + &g_PARAM_DIGEST_SHA512, + }; + const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *); + HksAddParams(paramInSet, paramDigest[GetRandom() % countOfDigest], 1); +} + +void ParamForSign(struct HksParamSet *paramInSet) +{ + const struct HksParam *paramAlgorithm[] = { + &g_PARAM_ALGORITHM_RSA, + &g_PARAM_ALGORITHM_ECC, +#ifndef _USE_MBEDTLS_ + &g_PARAM_ALGORITHM_DSA, +#endif + }; + const uint32_t count = sizeof(paramAlgorithm) / sizeof(struct HksParam *); + const uint32_t index = GetRandom() % count; + HksAddParams(paramInSet, paramAlgorithm[index], 1); + if (paramAlgorithm[index]->uint32Param == HKS_ALG_RSA) { + ParamForRSASign(paramInSet); + } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_ECC) { + ParamForECCSign(paramInSet); + } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_DSA) { + ParamForDSASign(paramInSet); + } +} + +void ParamForAgree(struct HksParamSet *generateKeyParam, struct HksParamSet *agreeKeyParam) +{ + const struct HksParam *paramAlg[] = { + &g_PARAM_ALGORITHM_ECDH, +#ifdef HKS_SUPPORT_DH_C + &g_PARAM_ALGORITHM_DH, +#endif + }; + const uint32_t countOfAlg = sizeof(paramAlg) / sizeof(struct HksParam *); + const uint32_t indexOfAlg = GetRandom() % countOfAlg; + + HksAddParams(agreeKeyParam, paramAlg[indexOfAlg], 1); + if (paramAlg[indexOfAlg]->uint32Param == HKS_ALG_ECDH) { + HksAddParams(generateKeyParam, &g_PARAM_ALGORITHM_ECC, 1); + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_ECC_224, + &g_PARAM_KEYSIZE_ECC_256, + &g_PARAM_KEYSIZE_ECC_384, + &g_PARAM_KEYSIZE_ECC_521, + }; + const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *); + const uint32_t indexOfKeySize = GetRandom() % countOfKeySize; + HksAddParams(generateKeyParam, paramKeySize[indexOfKeySize], 1); + HksAddParams(agreeKeyParam, paramKeySize[indexOfKeySize], 1); + HksAddParams(generateKeyParam, &g_PARAM_DIGEST_NONE, 1); + } +#ifdef HKS_SUPPORT_DH_C + if (paramAlg[indexOfAlg]->uint32Param == HKS_ALG_DH) { + HksAddParams(generateKeyParam, &g_PARAM_ALGORITHM_DH, 1); + const struct HksParam *paramKeySize[] = { + &g_PARAM_KEYSIZE_DH_2048, + &g_PARAM_KEYSIZE_DH_3072, + &g_PARAM_KEYSIZE_DH_4096, + }; + const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *); + const uint32_t indexOfKeySize = GetRandom() % countOfKeySize; + HksAddParams(generateKeyParam, paramKeySize[indexOfKeySize], 1); + HksAddParams(agreeKeyParam, paramKeySize[indexOfKeySize], 1); + } +#endif +} +} // namespace + +class ApiPressureTest : public testing::Test { +public: + void SetThreadState(bool threadState) + { + std::lock_guard lock(mutex_); + + threadState_ = threadState; + } + bool GetThreadState() + { + std::lock_guard lock(mutex_); + + return threadState_; + } + void GetSdkVersionTest(); + void InitializeTest(); + void RefreshKeyInfoTest(); + void GenerateKeyTest(); + void ImportKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void ExportPublicKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void DeleteKeyTest(uint32_t ii); + void GetKeyParamSetTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void KeyExistTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void GenerateRandomTest(); + void SignTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message); + void VerifyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message, + const struct HksBlob *signature); + void EncryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void DecryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, + const struct HksBlob *cipherText, uint32_t *inLen); + void AgreeKeyTest(const struct HksBlob *authId); + void DeriveKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void MacTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet); + void HashTest(); + void CipherScene(uint32_t ii); + void SignScene(uint32_t ii); + void AgreeScene(uint32_t ii); + +private: + bool threadState_; + std::mutex mutex_; +}; + +void ApiPressureTest::GetSdkVersionTest() +{ + do { + if (!GetThreadState()) { + break; + } + struct HksBlob sdkVersion = { .size = MAX_SDK_VERSION_SIZE, + .data = (uint8_t *)HksMalloc(MAX_SDK_VERSION_SIZE) }; + + EXPECT_EQ(HksGetSdkVersion(&sdkVersion), HKS_SUCCESS); + + HksFree(sdkVersion.data); + } while (1); +} + +void ApiPressureTest::InitializeTest() +{ + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksInitialize(), HKS_SUCCESS); + } while (1); +} + +void ApiPressureTest::RefreshKeyInfoTest() +{ + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksRefreshKeyInfo(), HKS_SUCCESS); + } while (1); +} + +void ApiPressureTest::GenerateKeyTest() +{ + do { + if (!GetThreadState()) { + break; + } + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS); + HksFreeParamSet(¶mInSet); + } while (1); +} + +void ApiPressureTest::ImportKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksExportPublicKey(authId, paramInSet, &pubKey); + do { + if (!GetThreadState()) { + break; + } + struct HksBlob importId = { (uint32_t)strlen(IMPORT_KEY), (uint8_t *)IMPORT_KEY }; + EXPECT_EQ(HksImportKey(&importId, paramInSet, &pubKey), HKS_SUCCESS); + } while (1); + HksFree(pubKey.data); +} + +void ApiPressureTest::ExportPublicKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + do { + if (!GetThreadState()) { + break; + } + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + EXPECT_EQ(HksExportPublicKey(authId, paramInSet, &pubKey), HKS_SUCCESS); + + HksFree(pubKey.data); + } while (1); +} + +void ApiPressureTest::DeleteKeyTest(uint32_t ii) +{ + do { + if (!GetThreadState()) { + break; + } + std::string key = "KeyForThread" + std::to_string(ii); + struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + EXPECT_EQ(HksDeleteKey(&authId, paramInSet), HKS_SUCCESS); + HksFreeParamSet(¶mInSet); + } while (1); +} + +void ApiPressureTest::GetKeyParamSetTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + do { + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = KEY_PARAMSET_SIZE, .data = (uint8_t *)HksMalloc(KEY_PARAMSET_SIZE) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksGetKeyParamSet(authId, paramInSet, paramOutSet), HKS_SUCCESS); + HksFree(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + } while (1); +} + +void ApiPressureTest::KeyExistTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksKeyExist(authId, paramInSet), HKS_SUCCESS); + } while (1); +} + +void ApiPressureTest::GenerateRandomTest() +{ + struct HksBlob authId = { .size = RANDOM_KEY_SIZE, .data = (uint8_t *)HksMalloc(RANDOM_KEY_SIZE) }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksGenerateRandom(paramInSet, &authId), HKS_SUCCESS); + } while (1); + HksFree(authId.data); + HksFreeParamSet(¶mInSet); +} + +void ApiPressureTest::SignTest( + const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message) +{ + do { + if (!GetThreadState()) { + break; + } + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + EXPECT_EQ(HksSign(authId, paramInSet, message, &signature), HKS_SUCCESS); + HksFree(signature.data); + } while (1); +} + +void ApiPressureTest::VerifyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, + const struct HksBlob *message, const struct HksBlob *signature) +{ + do { + if (!GetThreadState()) { + break; + } + EXPECT_EQ(HksVerify(authId, paramInSet, message, signature), HKS_SUCCESS); + } while (1); +} + +void ApiPressureTest::EncryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + uint32_t inLen = dataLen + COMPLEMENT_LEN; + do { + if (!GetThreadState()) { + break; + } + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + EXPECT_EQ(HksEncrypt(authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS); + HksFree(cipherText.data); + } while (1); +} + +void ApiPressureTest::DecryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, + const struct HksBlob *cipherText, uint32_t *inLen) +{ + do { + if (!GetThreadState()) { + break; + } + HksBlob plainTextDecrypt = { .size = *inLen, .data = (uint8_t *)HksMalloc(*inLen) }; + EXPECT_EQ(HksDecrypt(authId, paramInSet, cipherText, &plainTextDecrypt), HKS_SUCCESS); + HksFree(plainTextDecrypt.data); + } while (1); +} + +void ApiPressureTest::AgreeKeyTest(const struct HksBlob *authId) +{ + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksExportPublicKey(authId, NULL, &pubKey); + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + do { + if (!GetThreadState()) { + break; + } + HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + EXPECT_EQ(HksAgreeKey(paramInSet, authId, &pubKey, &agreeKey), HKS_SUCCESS); + HksFree(agreeKey.data); + } while (1); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); +} + +void ApiPressureTest::DeriveKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + do { + if (!GetThreadState()) { + break; + } + HksBlob derivedKey = { .size = DERIVE_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVE_KEY_SIZE) }; + EXPECT_EQ(HksDeriveKey(paramInSet, authId, &derivedKey), HKS_SUCCESS); + HksFree(derivedKey.data); + } while (1); +} + +void ApiPressureTest::MacTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet) +{ + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + do { + if (!GetThreadState()) { + break; + } + HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + EXPECT_EQ(HksMac(authId, paramInSet, &message, &macMessage), HKS_SUCCESS); + HksFree(macMessage.data); + } while (1); +} + +void ApiPressureTest::HashTest() +{ + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam digest = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }; + HksAddParams(paramInSet, &digest, 1); + HksBuildParamSet(¶mInSet); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + do { + if (!GetThreadState()) { + break; + } + HksBlob shaMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + EXPECT_EQ(HksHash(paramInSet, &message, &shaMessage), HKS_SUCCESS); + HksFree(shaMessage.data); + } while (1); + HksFreeParamSet(¶mInSet); +} + +void ApiPressureTest::CipherScene(uint32_t ii) +{ + std::string key = "KeyForThread" + std::to_string(ii); + struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] }; + do { + if (!GetThreadState()) { + break; + } + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + HksAddParams(paramInSet, CIPHER_PARAMS, sizeof(CIPHER_PARAMS) / sizeof(CIPHER_PARAMS[0])); + ParamForCipher(paramInSet); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + struct HksParam *padding = nullptr; + HksGetParam(paramInSet, HKS_TAG_PADDING, &padding); + char hexData[MAX_STRING_LENTH] = {0}; + uint32_t dataLen; + struct HksParam *algorithm = nullptr; + HksGetParam(paramInSet, HKS_TAG_ALGORITHM, &algorithm); + if (algorithm->uint32Param == HKS_ALG_RSA) { + if (padding->uint32Param == HKS_PADDING_NONE) { + struct HksParam *keySize = nullptr; + HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &keySize); + dataLen = HKS_KEY_BYTES(keySize->uint32Param); + } else { + dataLen = RSA_MESSAGE_SIZE; + } + } else { + dataLen = AES_MESSAGE_SIZE; + } + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob cipherText = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) }; + HksEncrypt(&authId, paramInSet, &plainText, &cipherText); + HksBlob plainTextDecrypt = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) }; + EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS); + HksFree(plainTextDecrypt.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); + } while (1); +} + +void ApiPressureTest::SignScene(uint32_t ii) +{ + std::string key = "KeyForThread" + std::to_string(ii); + struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] }; + do { + if (!GetThreadState()) { + break; + } + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + ParamForSign(paramInSet); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) }; + HksSign(&authId, paramInSet, &message, &signature); + EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS); + HksFree(signature.data); + HksFreeParamSet(¶mInSet); + } while (1); +} + +void ApiPressureTest::AgreeScene(uint32_t ii) +{ + std::string key = "KeyForThread" + std::to_string(ii); + struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] }; + do { + if (!GetThreadState()) { + break; + } + struct HksParamSet *generateKeyParam = nullptr; + HksInitParamSet(&generateKeyParam); + struct HksParamSet *agreeKeyParam = nullptr; + HksInitParamSet(&agreeKeyParam); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(generateKeyParam, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksAddParams(agreeKeyParam, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + ParamForAgree(generateKeyParam, agreeKeyParam); + HksBuildParamSet(&generateKeyParam); + HksBuildParamSet(&agreeKeyParam); + HksGenerateKey(&authId, generateKeyParam, NULL); + struct HksBlob pubKey = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) }; + HksExportPublicKey(&authId, generateKeyParam, &pubKey); + HksBlob agreeKey = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) }; + EXPECT_EQ(HksAgreeKey(agreeKeyParam, &authId, &pubKey, &agreeKey), HKS_SUCCESS); + HksFree(agreeKey.data); + HksFree(pubKey.data); + HksFreeParamSet(&generateKeyParam); + HksFreeParamSet(&agreeKeyParam); + } while (1); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00100 + * @tc.name : ApiPressureTest00100 + * @tc.desc : HksGetSdkVersion + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00100, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::GetSdkVersionTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00200 + * @tc.name : ApiPressureTest00200 + * @tc.desc : HksInitialize + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00200, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::InitializeTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00300 + * @tc.name : ApiPressureTest00300 + * @tc.desc : HksRefreshKeyInfo + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00300, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::RefreshKeyInfoTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00400 + * @tc.name : ApiPressureTest00400 + * @tc.desc : HksGenerateKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00400, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::GenerateKeyTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00500 + * @tc.name : ApiPressureTest00500 + * @tc.desc : HksImportKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00500, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::ImportKeyTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00600 + * @tc.name : ApiPressureTest00600 + * @tc.desc : HksExportPublicKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00600, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::ExportPublicKeyTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00700 + * @tc.name : ApiPressureTest00700 + * @tc.desc : HksDeleteKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00700, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::DeleteKeyTest, this, ii)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00800 + * @tc.name : ApiPressureTest00800 + * @tc.desc : HksGetKeyParamSet + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00800, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::GetKeyParamSetTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest00900 + * @tc.name : ApiPressureTest00900 + * @tc.desc : HksKeyExist + */ +HWTEST_F(ApiPressureTest, ApiPressureTest00900, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::KeyExistTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01000 + * @tc.name : ApiPressureTest01000 + * @tc.desc : HksGenerateRandom + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01000, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::GenerateRandomTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01100 + * @tc.name : ApiPressureTest01100 + * @tc.desc : HksSign + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01100, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::SignTest, this, &authId, paramInSet, &message)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01200 + * @tc.name : ApiPressureTest01200 + * @tc.desc : HksVerify + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01200, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksSign(&authId, paramInSet, &message, &signature); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back( + std::thread(&ApiPressureTest::VerifyTest, this, &authId, paramInSet, &message, &signature)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFree(signature.data); + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01300 + * @tc.name : ApiPressureTest01300 + * @tc.desc : HksEncrypt + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01300, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + }; + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::EncryptTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01400 + * @tc.name : ApiPressureTest01400 + * @tc.desc : HksDecrypt + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01400, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + }; + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + HksEncrypt(&authId, paramInSet, &plainText, &cipherText); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back( + std::thread(&ApiPressureTest::DecryptTest, this, &authId, paramInSet, &cipherText, &inLen)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01500 + * @tc.name : ApiPressureTest01500 + * @tc.desc : HksAgreeKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01500, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::AgreeKeyTest, this, &authId)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01600 + * @tc.name : ApiPressureTest01600 + * @tc.desc : HksDeriveKey + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01600, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + struct HksParamSet *paramInSetHkdf = nullptr; + HksInitParamSet(¶mInSetHkdf); + struct HksParam tmpParamsHkdf[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSetHkdf, tmpParamsHkdf, sizeof(tmpParamsHkdf) / sizeof(tmpParamsHkdf[0])); + HksBuildParamSet(¶mInSetHkdf); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::DeriveKeyTest, this, &authId, paramInSetHkdf)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mInSetHkdf); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01700 + * @tc.name : ApiPressureTest01700 + * @tc.desc : HksMac + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01700, TestSize.Level1) +{ + std::vector threads; + struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + HksGenerateKey(&authId, paramInSet, NULL); + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::MacTest, this, &authId, paramInSet)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } + HksFreeParamSet(¶mInSet); +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01800 + * @tc.name : ApiPressureTest01800 + * @tc.desc : HksHash + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01800, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::HashTest, this)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest01900 + * @tc.name : ApiPressureTest01900 + * @tc.desc : Scenario 1: generate key and encrypt / decrypt + */ +HWTEST_F(ApiPressureTest, ApiPressureTest01900, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::CipherScene, this, ii)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest02000 + * @tc.name : ApiPressureTest02000 + * @tc.desc : Scenario 2: generate key and sign / verify + */ +HWTEST_F(ApiPressureTest, ApiPressureTest02000, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::SignScene, this, ii)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} + +/** + * @tc.number : ApiPressureTest.ApiPressureTest02100 + * @tc.name : ApiPressureTest02100 + * @tc.desc : Scenario 3: generate key and agree + */ +HWTEST_F(ApiPressureTest, ApiPressureTest02100, TestSize.Level1) +{ + std::vector threads; + SetThreadState(true); + for (uint32_t ii = 0; ii < THREADS_NUM; ii++) { + threads.emplace_back(std::thread(&ApiPressureTest::AgreeScene, this, ii)); + } + std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS)); + SetThreadState(false); + for (auto &t : threads) { + t.join(); + } +} +} // namespace \ No newline at end of file diff --git a/test/stability/src/pressure_test.cpp b/test/stability/src/pressure_test.cpp new file mode 100755 index 00000000..286e4b65 --- /dev/null +++ b/test/stability/src/pressure_test.cpp @@ -0,0 +1,1263 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include "hks_api.h" +#include "hks_log.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; +namespace { +namespace { +const char GENERATE_KEY[] = "This is for generate key"; +const char IMPORT_KEY[] = "This is for import key"; +const uint32_t TEST_FREQUENCY = 1000; +const uint32_t MAX_SDK_VERSION_SIZE = 64; +const uint32_t IV_SIZE = 16; +const uint32_t COMPLEMENT_LEN = 16; +const uint32_t KEY_PARAMSET_SIZE = 1024; +const uint32_t MESSAGE_SIZE = 64; +const uint32_t TEST_KEY_SIZE = 512; +const uint32_t DERIVED_KEY_SIZE = 64; + +static const struct HksParam PARAMS_FOR_ENCRYPT[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, +}; + +static const struct HksParam PARAMS_FOR_DECRYPT[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, +}; +} // namespace +class PressureTest : public testing::Test { +public: + int32_t LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, const struct HksParamSet *paramSetIn, + struct HksBlob *priKey, struct HksBlob *pubKey); +}; + +int32_t PressureTest::LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, + const struct HksParamSet *paramSetIn, struct HksBlob *priKey, struct HksBlob *pubKey) +{ + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + if (HksGenerateKey(authId, paramSetIn, paramOutSet) != HKS_SUCCESS) { + return HKS_SUCCESS; + } + + HksParam *priParam = nullptr; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam); + priKey->size = priParam->blob.size; + (void)memcpy_s(priKey->data, priKey->size, priParam->blob.data, priParam->blob.size); + + HksParam *pubParam = nullptr; + HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam); + pubKey->size = pubParam->blob.size; + (void)memcpy_s(pubKey->data, pubKey->size, pubParam->blob.data, pubParam->blob.size); + + HksFree(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + return HKS_SUCCESS; +} + +/** + * @tc.number : PressureTest.PressureTest00100 + * @tc.name : PressureTest00100 + * @tc.desc : HksGetSdkVersion + */ +HWTEST_F(PressureTest, PressureTest00100, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob sdkVersion = { .size = MAX_SDK_VERSION_SIZE, + .data = (uint8_t *)HksMalloc(MAX_SDK_VERSION_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGetSdkVersion(&sdkVersion); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + HksFree(sdkVersion.data); + } + HKS_LOG_I("HksGetSdkVersion Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00200 + * @tc.name : PressureTest00200 + * @tc.desc : HksInitialize + */ +HWTEST_F(PressureTest, PressureTest00200, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksInitialize(); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HKS_LOG_I("HksInitialize Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00300 + * @tc.name : PressureTest00300 + * @tc.desc : HksRefreshKeyInfo + */ +HWTEST_F(PressureTest, PressureTest00300, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksRefreshKeyInfo(); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HKS_LOG_I("HksRefreshKeyInfo Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00400 + * @tc.name : PressureTest00400 + * @tc.desc : HksGenerateKey + */ +HWTEST_F(PressureTest, PressureTest00400, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGenerateKey(&authId, paramInSet, NULL); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + } + HKS_LOG_I("HksGenerateKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00500 + * @tc.name : PressureTest00500 + * @tc.desc : HksImportKey + */ +HWTEST_F(PressureTest, PressureTest00500, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksExportPublicKey(&authId, paramInSet, &pubKey); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob importId = { strlen(IMPORT_KEY), (uint8_t *)IMPORT_KEY }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksImportKey(&importId, paramInSet, &pubKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + HksDeleteKey(&importId, paramInSet); + } + HksDeleteKey(&authId, paramInSet); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksImportKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00600 + * @tc.name : PressureTest00600 + * @tc.desc : HksExportPublicKey + */ +HWTEST_F(PressureTest, PressureTest00600, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksExportPublicKey(&authId, paramInSet, &pubKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(pubKey.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksExportPublicKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00700 + * @tc.name : PressureTest00700 + * @tc.desc : HksDeleteKey + */ +HWTEST_F(PressureTest, PressureTest00700, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDeleteKey(&authId, paramInSet); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFreeParamSet(¶mInSet); + } + HKS_LOG_I("HksDeleteKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00800 + * @tc.name : PressureTest00800 + * @tc.desc : HksGetKeyParamSet + */ +HWTEST_F(PressureTest, PressureTest00800, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = KEY_PARAMSET_SIZE, .data = (uint8_t *)HksMalloc(KEY_PARAMSET_SIZE) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGetKeyParamSet(&authId, paramInSet, paramOutSet); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(localKey.blob.data); + HksFreeParamSet(¶mOutSet); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksGetKeyParamSet Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest00900 + * @tc.name : PressureTest00900 + * @tc.desc : HksKeyExist + */ +HWTEST_F(PressureTest, PressureTest00900, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksKeyExist(&authId, paramInSet); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksKeyExist Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01000 + * @tc.name : PressureTest01000 + * @tc.desc : HksGenerateRandom + */ +HWTEST_F(PressureTest, PressureTest01000, TestSize.Level1) +{ + double programTimes = 0; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksBlob authId = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) }; + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGenerateRandom(paramInSet, &authId); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(authId.data); + HksFreeParamSet(¶mInSet); + } + HKS_LOG_I("HksGenerateRandom Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01100 + * @tc.name : PressureTest01100 + * @tc.desc : HksSign + */ +HWTEST_F(PressureTest, PressureTest01100, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksSign(&authId, paramInSet, &message, &signature); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(signature.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksSign Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01200 + * @tc.name : PressureTest01200 + * @tc.desc : HksVerify + */ +HWTEST_F(PressureTest, PressureTest01200, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + HksSign(&authId, paramInSet, &message, &signature); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksVerify(&authId, paramInSet, &message, &signature); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HksDeleteKey(&authId, paramInSet); + HksFree(signature.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksVerify Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01300 + * @tc.name : PressureTest01300 + * @tc.desc : HksEncrypt + */ +HWTEST_F(PressureTest, PressureTest01300, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + }; + + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksEncrypt(&authId, paramInSet, &plainText, &cipherText); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(cipherText.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksEncrypt Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01400 + * @tc.name : PressureTest01400 + * @tc.desc : HksDecrypt + */ +HWTEST_F(PressureTest, PressureTest01400, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC }, + }; + + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + + HksEncrypt(&authId, paramInSet, &plainText, &cipherText); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(plainTextDecrypt.data); + } + HksDeleteKey(&authId, paramInSet); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksDecrypt Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01500 + * @tc.name : PressureTest01500 + * @tc.desc : HksAgreeKey + */ +HWTEST_F(PressureTest, PressureTest01500, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksExportPublicKey(&authId, paramInSet, &pubKey); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksAgreeKey(paramInSet, &authId, &pubKey, &agreeKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(agreeKey.data); + } + HksDeleteKey(&authId, paramInSet); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksAgreeKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01600 + * @tc.name : PressureTest01600 + * @tc.desc : HksDeriveKey + */ +HWTEST_F(PressureTest, PressureTest01600, TestSize.Level1) +{ + double programTimes = 0; + + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + struct HksParamSet *paramInSetHkdf = nullptr; + HksInitParamSet(¶mInSetHkdf); + struct HksParam tmpParamsHkdf[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DERIVED_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSetHkdf, tmpParamsHkdf, sizeof(tmpParamsHkdf) / sizeof(tmpParamsHkdf[0])); + HksBuildParamSet(¶mInSetHkdf); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob derivedKey = { .size = DERIVED_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVED_KEY_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDeriveKey(paramInSetHkdf, &authId, &derivedKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(derivedKey.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mInSetHkdf); + HKS_LOG_I("HksDeriveKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01700 + * @tc.name : PressureTest01700 + * @tc.desc : HksMac + */ +HWTEST_F(PressureTest, PressureTest01700, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateKey(&authId, paramInSet, NULL); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksMac(&authId, paramInSet, &message, &macMessage); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(macMessage.data); + } + HksDeleteKey(&authId, paramInSet); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksMac Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01800 + * @tc.name : PressureTest01800 + * @tc.desc : HksHash + */ +HWTEST_F(PressureTest, PressureTest01800, TestSize.Level1) +{ + double programTimes = 0; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam digest = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }; + HksAddParams(paramInSet, &digest, 1); + HksBuildParamSet(¶mInSet); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob shaMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksHash(paramInSet, &message, &shaMessage); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(shaMessage.data); + } + HksFreeParamSet(¶mInSet); + HKS_LOG_I("HksHash Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest01900 + * @tc.name : PressureTest01900 + * @tc.desc : HksGenerateKey + */ +HWTEST_F(PressureTest, PressureTest01900, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) } }; + HksAddParams(paramOutSet, &localKey, 1); + + HksBuildParamSet(¶mOutSet); + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksGenerateKey(&authId, paramInSet, paramOutSet); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(localKey.blob.data); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + } + HKS_LOG_I("Local HksGenerateKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02000 + * @tc.name : PressureTest02000 + * @tc.desc : HksSign + */ +HWTEST_F(PressureTest, PressureTest02000, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSet, &priKey, &pubKey); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksSign(&priKey, paramInSet, &message, &signature); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(signature.data); + } + HksFree(priKey.data); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("Local HksSign Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02100 + * @tc.name : PressureTest02100 + * @tc.desc : HksVerify + */ +HWTEST_F(PressureTest, PressureTest02100, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSet, &priKey, &pubKey); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + HksSign(&priKey, paramInSet, &message, &signature); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksVerify(&pubKey, paramInSet, &message, &signature); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + } + HksFree(priKey.data); + HksFree(pubKey.data); + HksFree(signature.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("Local HksVerify Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02200 + * @tc.name : PressureTest02200 + * @tc.desc : HksEncrypt + */ +HWTEST_F(PressureTest, PressureTest02200, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + + HksAddParams(paramInSet, PARAMS_FOR_ENCRYPT, sizeof(PARAMS_FOR_ENCRYPT) / sizeof(PARAMS_FOR_ENCRYPT[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + HksGenerateKey(&authId, paramInSet, paramOutSet); + + HksParam *paramOut = nullptr; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, ¶mOut); + HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) }; + (void)memcpy_s(authKey.data, authKey.size, paramOut->blob.data, paramOut->blob.size); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksEncrypt(&authKey, paramInSet, &plainText, &cipherText); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(cipherText.data); + } + HksFree(localKey.blob.data); + HksFree(authKey.data); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + HKS_LOG_I("Local HksEncrypt Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02300 + * @tc.name : PressureTest02300 + * @tc.desc : HksDecrypt + */ +HWTEST_F(PressureTest, PressureTest02300, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + uint8_t iv[IV_SIZE] = {0}; + struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } }; + HksAddParams(paramInSet, &tagIv, 1); + + HksAddParams(paramInSet, PARAMS_FOR_DECRYPT, sizeof(PARAMS_FOR_DECRYPT) / sizeof(PARAMS_FOR_DECRYPT[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + HksGenerateKey(&authId, paramInSet, paramOutSet); + + HksParam *paramOut = nullptr; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, ¶mOut); + HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) }; + (void)memcpy_s(authKey.data, authKey.size, paramOut->blob.data, paramOut->blob.size); + + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData }; + + uint32_t inLen = dataLen + COMPLEMENT_LEN; + HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + + HksEncrypt(&authKey, paramInSet, &plainText, &cipherText); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDecrypt(&authKey, paramInSet, &cipherText, &plainTextDecrypt); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(plainTextDecrypt.data); + } + HksFree(localKey.blob.data); + HksFree(authKey.data); + HksFree(cipherText.data); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + HKS_LOG_I("Local HksDecrypt Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02400 + * @tc.name : PressureTest02400 + * @tc.desc : HksAgreeKey + */ +HWTEST_F(PressureTest, PressureTest02400, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + + PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSet, &priKey, &pubKey); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksAgreeKey(paramInSet, &priKey, &pubKey, &agreeKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(agreeKey.data); + } + HksFree(priKey.data); + HksFree(pubKey.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("Local HksAgreeKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02500 + * @tc.name : PressureTest02500 + * @tc.desc : HksDeriveKey + */ +HWTEST_F(PressureTest, PressureTest02500, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DERIVED_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + HksGenerateRandom(paramInSet, &authId); + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + HksBlob derivedKey = { .size = DERIVED_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVED_KEY_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksDeriveKey(paramInSet, &authId, &derivedKey); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(derivedKey.data); + } + HksFree(authId.data); + HksFreeParamSet(¶mInSet); + HKS_LOG_I("Local HksDeriveKey Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} + +/** + * @tc.number : PressureTest.PressureTest02600 + * @tc.name : PressureTest02600 + * @tc.desc : HksMac + */ +HWTEST_F(PressureTest, PressureTest02600, TestSize.Level1) +{ + double programTimes = 0; + struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY }; + + struct HksParamSet *paramInSet = nullptr; + HksInitParamSet(¶mInSet); + + struct HksParam tmpParams[] = { + { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP }, + { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC }, + { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE }, + { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC }, + { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 }, + { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false }, + { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT }, + }; + + HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0])); + HksBuildParamSet(¶mInSet); + + struct HksParamSet *paramOutSet = nullptr; + HksInitParamSet(¶mOutSet); + struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA, + .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } }; + HksAddParams(paramOutSet, &localKey, 1); + HksBuildParamSet(¶mOutSet); + + HksGenerateKey(&authId, paramInSet, paramOutSet); + + HksParam *paramOut = nullptr; + HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, ¶mOut); + HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) }; + (void)memcpy_s(authKey.data, authKey.size, paramOut->blob.data, paramOut->blob.size); + + for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) { + const char *hexData = "0123456789abcdef"; + uint32_t dataLen = strlen(hexData); + HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData }; + HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) }; + auto start = std::chrono::time_point_cast(std::chrono::system_clock::now()); + int32_t ret = HksMac(&authKey, paramInSet, &message, &macMessage); + auto end = std::chrono::time_point_cast(std::chrono::system_clock::now()); + EXPECT_EQ(ret, HKS_SUCCESS); + programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count()); + + HksFree(macMessage.data); + } + HksFree(localKey.blob.data); + HksFree(authKey.data); + HksFreeParamSet(¶mInSet); + HksFreeParamSet(¶mOutSet); + HKS_LOG_I("Local HksMac Interface Call Duration: %f", (programTimes / TEST_FREQUENCY)); +} +} // namespace \ No newline at end of file -- Gitee From 2f0a6f688f72718d63be1b6b92ca7cbc7c38848b Mon Sep 17 00:00:00 2001 From: SryLideming Date: Tue, 14 Dec 2021 21:47:39 +0800 Subject: [PATCH 12/12] patch for my last commit merage pr:18/20 Signed-off-by: SryLideming --- ohos.build | 3 +- .../core/src/hks_client_service_adapter.c | 2 - .../main/core/src/hks_storage_file_lock.c | 31 +- test/fuzz/BUILD.gn | 43 + test/fuzz/src/huks_fuzz_test.cpp | 825 ++++++++++++++++++ 5 files changed, 893 insertions(+), 11 deletions(-) create mode 100755 test/fuzz/BUILD.gn create mode 100755 test/fuzz/src/huks_fuzz_test.cpp diff --git a/ohos.build b/ohos.build index ee81bf84..4f7b394d 100755 --- a/ohos.build +++ b/ohos.build @@ -27,7 +27,8 @@ "//base/security/huks:huks_sdk_test", "//base/security/huks/services/huks_standard/huks_service/main/test/unittest:huks_multithread_test", "//base/security/huks/interfaces/innerkits/huks_standard/test/moduletest:huks_mt_test", - "//base/security/huks/test/stability:huks_stability_test" + "//base/security/huks/test/stability:huks_stability_test", + "//base/security/huks/test/fuzz:huks_fuzz_test" ] } } diff --git a/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c b/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c index c133c6b9..e310c03a 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c +++ b/services/huks_standard/huks_service/main/core/src/hks_client_service_adapter.c @@ -98,8 +98,6 @@ static int32_t RsaToX509PublicKey(const struct HksBlob *mod, const struct HksBlo HKS_LOG_E("EVP_PKEY_set1_RSA error %s", ERR_reason_error_string(ERR_get_error())); break; } - /* rsa need to be set to null to prevent Double-Free */ - rsa = NULL; result = EvpKeyToX509Format(pkey, x509Key); } while (0); diff --git a/services/huks_standard/huks_service/main/core/src/hks_storage_file_lock.c b/services/huks_standard/huks_service/main/core/src/hks_storage_file_lock.c index eaf2ed28..565d1bbb 100755 --- a/services/huks_standard/huks_service/main/core/src/hks_storage_file_lock.c +++ b/services/huks_standard/huks_service/main/core/src/hks_storage_file_lock.c @@ -134,9 +134,18 @@ static void AppendFileLock(HksStorageFileLock *lock) HksStorageFileLock *HksStorageFileLockCreate(char *path) { - HksStorageFileLock *lock = NULL; - HksMutexLock(g_lockListLock); - lock = FindFileLock(path); + if (path == NULL) { + return NULL; + } + + if (g_lockListLock == NULL) { + return NULL; + } + + if (HksMutexLock(g_lockListLock) != 0) { + return NULL; + } + HksStorageFileLock *lock = FindFileLock(path); if (lock == NULL) { lock = AllocFileLock(path); if (lock != NULL) { @@ -145,7 +154,7 @@ HksStorageFileLock *HksStorageFileLockCreate(char *path) } else { AddRef(lock); } - HksMutexUnlock(g_lockListLock); + (void)HksMutexUnlock(g_lockListLock); return lock; } @@ -236,23 +245,29 @@ void HksStorageFileLockRelease(HksStorageFileLock *lock) return; } - HksMutexLock(g_lockListLock); + if (g_lockListLock == NULL) { + return; + } + + if (HksMutexLock(g_lockListLock) != 0) { + return; + } if (IsLockInList(lock)) { Release(lock); } - HksMutexUnlock(g_lockListLock); + (void)HksMutexUnlock(g_lockListLock); } -__attribute__((constructor)) void OnLoad(void) +__attribute__((constructor)) static void OnLoad(void) { g_lockListLock = HksMutexCreate(); g_lockListFirst = NULL; g_lockListLast = NULL; } -__attribute__((destructor)) void OnUnload(void) +__attribute__((destructor)) static void OnUnload(void) { if (g_lockListLock != NULL) { HksMutexClose(g_lockListLock); diff --git a/test/fuzz/BUILD.gn b/test/fuzz/BUILD.gn new file mode 100755 index 00000000..0e102734 --- /dev/null +++ b/test/fuzz/BUILD.gn @@ -0,0 +1,43 @@ +# Copyright (C) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//base/security/huks/huks.gni") +import("//build/test.gni") + +module_output_path = "huks_standard/huks_standard_test" + +ohos_moduletest("huks_fuzz_test") { + module_out_path = module_output_path + sources = [ "src/huks_fuzz_test.cpp" ] + + if (use_crypto_lib == "openssl") { + defines = [ "_USE_OPENSSL_" ] + } + if (use_crypto_lib == "mbedtls") { + defines = [ "_USE_MBEDTLS_" ] + } + + include_dirs = [ + "//utils/native/base/include", + "//third_party/bounds_checking_function/include", + "//base/security/huks/interfaces/innerkits/huks_standard/main/include", + "include", + ] + deps = [ + "//base/security/huks/frameworks/huks_standard/main:huks_standard_frameworks", + "//base/security/huks/interfaces/innerkits/huks_standard/main:libhukssdk", + "//third_party/bounds_checking_function:libsec_static", + "//third_party/googletest:gtest_main", + "//utils/native/base:utils", + ] +} diff --git a/test/fuzz/src/huks_fuzz_test.cpp b/test/fuzz/src/huks_fuzz_test.cpp new file mode 100755 index 00000000..3f5eb7a8 --- /dev/null +++ b/test/fuzz/src/huks_fuzz_test.cpp @@ -0,0 +1,825 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +#include + +#include "hks_api.h" +#include "hks_mem.h" +#include "hks_param.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Security { +namespace Huks { +namespace FuzzTest { +namespace { +constexpr uint32_t HUKS_FUZZ_TEST_HOURS = 12; +constexpr auto HUKS_FUZZ_TEST_TIME = std::chrono::hours(HUKS_FUZZ_TEST_HOURS); +constexpr uint32_t MAX_PARAM_COUNT_IN_PARAM_SET = 32; +constexpr uint32_t MAX_RANDOM_BYTES = 32; +constexpr uint32_t BITS_32 = 32; +constexpr uint32_t MOD_2 = 2; +constexpr uint32_t MAX_BYTES_BN = 512; + +enum class HuksApi : uint32_t { + GENERATE_KEY = 0, + IMPORT_KEY, + GET_SDK_VERSION, + INITIALIZE, + REFRESH_KEY_INFO, + EXPORT_PUBLIC_KEY, + DELETE_KEY, + GET_KEY_PARAMSET, + KEY_EXIST, + GENERATE_RANDOM, + SIGN, + VERIFY, + ENCRYPT, + DECRYPT, + AGREE_KEY, + DERIVE_KEY, + MAC, + HASH, + GET_KEY_INFO_LIST, + ATTEST_KEY, + GET_CERTIFICATE_CHAIN, + WRAP_KEY, + UNWRAP_KEY, + BN_EXP_MOD, + HCM_IS_DEVICE_KEY_EXIST, + HUKS_API_MAX, +}; +} // namespace + +class HuksFuzzTest : public testing::Test { +protected: + void RunFuzzTest() const; + +private: + uint32_t RandomUint32() const; + bool RandomBool() const; + const std::function RandomHuksApi() const; + uint8_t *RandomByte(uint32_t length) const; + struct HksBlob *RandomBlob(uint32_t maxSize = MAX_OUT_BLOB_SIZE) const; + struct HksParamSet *RandomParamSetIn() const; + struct HksParamSet *RandomParamSetOut() const; + struct HksKeyInfo *RandomKeyInfoOut() const; + struct HksCertChain *RandomCertChainOut() const; + + void FreeBlob(struct HksBlob *&blob) const; + void FreeKeyInfoOut(struct HksKeyInfo *&keyInfo) const; + void FreeCertChainOut(struct HksCertChain *&certchain) const; + +private: + void HuksFuzzGenerateKey() const; + void HuksFuzzImportKey() const; + void HuksFuzzGetSdkVersion() const; + void HuksFuzzInitialize() const; + void HuksFuzzRefreshKeyInfo() const; + void HuksFuzzExportPublicKey() const; + void HuksFuzzDeleteKey() const; + void HuksFuzzGetKeyParamSet() const; + void HuksFuzzKeyExist() const; + void HuksFuzzGenerateRandom() const; + void HuksFuzzSign() const; + void HuksFuzzVerify() const; + void HuksFuzzEncrypt() const; + void HuksFuzzDecrypt() const; + void HuksFuzzAgreeKey() const; + void HuksFuzzDeriveKey() const; + void HuksFuzzMac() const; + void HuksFuzzHash() const; + void HuksFuzzGetKeyInfoList() const; + void HuksFuzzAttestKey() const; + void HuksFuzzGetCertificateChain() const; + void HuksFuzzWrapKey() const; + void HuksFuzzUnwrapKey() const; + void HuksFuzzBnExpMod() const; + void HuksFuzzHcmIsDeviceKeyExist() const; + + const std::function fuzzApiList_[static_cast(HuksApi::HUKS_API_MAX)] = { + std::bind(&HuksFuzzTest::HuksFuzzGenerateKey, this), + std::bind(&HuksFuzzTest::HuksFuzzImportKey, this), + std::bind(&HuksFuzzTest::HuksFuzzGetSdkVersion, this), + std::bind(&HuksFuzzTest::HuksFuzzInitialize, this), + std::bind(&HuksFuzzTest::HuksFuzzRefreshKeyInfo, this), + std::bind(&HuksFuzzTest::HuksFuzzExportPublicKey, this), + std::bind(&HuksFuzzTest::HuksFuzzDeleteKey, this), + std::bind(&HuksFuzzTest::HuksFuzzGetKeyParamSet, this), + std::bind(&HuksFuzzTest::HuksFuzzKeyExist, this), + std::bind(&HuksFuzzTest::HuksFuzzGenerateRandom, this), + std::bind(&HuksFuzzTest::HuksFuzzSign, this), + std::bind(&HuksFuzzTest::HuksFuzzVerify, this), + std::bind(&HuksFuzzTest::HuksFuzzEncrypt, this), + std::bind(&HuksFuzzTest::HuksFuzzDecrypt, this), + std::bind(&HuksFuzzTest::HuksFuzzAgreeKey, this), + std::bind(&HuksFuzzTest::HuksFuzzDeriveKey, this), + std::bind(&HuksFuzzTest::HuksFuzzMac, this), + std::bind(&HuksFuzzTest::HuksFuzzHash, this), + std::bind(&HuksFuzzTest::HuksFuzzGetKeyInfoList, this), + std::bind(&HuksFuzzTest::HuksFuzzAttestKey, this), + std::bind(&HuksFuzzTest::HuksFuzzGetCertificateChain, this), + std::bind(&HuksFuzzTest::HuksFuzzWrapKey, this), + std::bind(&HuksFuzzTest::HuksFuzzUnwrapKey, this), + std::bind(&HuksFuzzTest::HuksFuzzBnExpMod, this), + std::bind(&HuksFuzzTest::HuksFuzzHcmIsDeviceKeyExist, this), + }; +}; + +void HuksFuzzTest::RunFuzzTest() const +{ + auto api = RandomHuksApi(); + return api(); +} + +uint32_t HuksFuzzTest::RandomUint32() const +{ + std::random_device rd; + return rd(); +} + +bool HuksFuzzTest::RandomBool() const +{ + return (RandomUint32() % MOD_2); +} + +const std::function HuksFuzzTest::RandomHuksApi() const +{ + uint32_t index = RandomUint32() % static_cast(HuksApi::HUKS_API_MAX); + return fuzzApiList_[index]; +} + +uint8_t *HuksFuzzTest::RandomByte(uint32_t length) const +{ + if (length == 0) { + return nullptr; + } + + uint8_t *data = (uint8_t *)HksMalloc(length); + if (data != nullptr) { + std::generate(data, data + (length > MAX_RANDOM_BYTES ? MAX_RANDOM_BYTES : length), []() { + std::random_device rd; + return rd(); + }); + } + + return data; +} + +struct HksBlob *HuksFuzzTest::RandomBlob(uint32_t maxSize) const +{ + if (maxSize == 0) { + return nullptr; + } + + if (RandomUint32() == 0) { + return nullptr; + } + + struct HksBlob *blob = (struct HksBlob *)HksMalloc(sizeof(struct HksBlob)); + if (blob != nullptr) { + uint32_t size = RandomUint32() % maxSize; + if (size != 0) { + blob->size = size; + blob->data = RandomByte(blob->size); + } else { + blob->size = 0; + blob->data = nullptr; + } + if (blob->data == nullptr) { + blob->size = 0; + } + } + + return blob; +} + +void HuksFuzzTest::FreeBlob(struct HksBlob *&blob) const +{ + if (blob == nullptr) { + return; + } + + if (blob->data != nullptr) { + HksFree(blob->data); + blob->data = NULL; + } + + HksFree(blob); + blob = nullptr; +} + +void HuksFuzzTest::FreeKeyInfoOut(struct HksKeyInfo *&keyInfo) const +{ + if (keyInfo == nullptr) { + return; + } + + if (keyInfo->paramSet != nullptr) { + HksFreeParamSet(&keyInfo->paramSet); + } + + HksFree(keyInfo); + keyInfo = nullptr; +} + +void HuksFuzzTest::FreeCertChainOut(struct HksCertChain *&certchain) const +{ + if (certchain == nullptr) { + return; + } + + if (certchain->certs != nullptr) { + for (uint32_t ii = 0; ii < certchain->certsCount; ii++) { + if (certchain->certs[ii].data != nullptr) { + HksFree(certchain->certs[ii].data); + } + } + } + + HksFree(certchain); + certchain = nullptr; +} + +struct HksParamSet *HuksFuzzTest::RandomParamSetIn() const +{ + if (RandomUint32() == 0) { + return nullptr; + } + + struct HksParamSet *paramSet = nullptr; + int32_t result = HksInitParamSet(¶mSet); + if (result != HKS_SUCCESS) { + return nullptr; + } + + std::vector params; + uint32_t paramCount = RandomUint32() % MAX_PARAM_COUNT_IN_PARAM_SET; + for (uint32_t i = 0; i < paramCount; i++) { + struct HksParam param = {0}; + param.tag = RandomUint32(); + if ((param.tag & HKS_TAG_TYPE_INT) || (param.tag & HKS_TAG_TYPE_UINT)) { + param.uint32Param = RandomUint32(); + } else if (param.tag & HKS_TAG_TYPE_ULONG) { + param.uint64Param = (((uint64_t)RandomUint32() << BITS_32) || RandomUint32()); + } else if (param.tag & HKS_TAG_TYPE_BOOL) { + param.boolParam = RandomBool(); + } else if (param.tag & HKS_TAG_TYPE_BYTES) { + param.blob.size = RandomUint32() / MAX_KEY_SIZE; + if (param.blob.size != 0) { + param.blob.data = RandomByte(param.blob.size); + } else { + param.blob.data = nullptr; + } + if (param.blob.data == nullptr) { + param.blob.size = 0; + } + } + params.push_back(param); + } + result = HksAddParams(paramSet, params.data(), params.size()); + + result = HksBuildParamSet(¶mSet); + + for (auto param : params) { + if (param.tag & HKS_TAG_TYPE_BYTES) { + if (param.blob.data != nullptr) { + HksFree(param.blob.data); + param.blob.data = 0; + } + } + } + return paramSet; +} + +struct HksParamSet *HuksFuzzTest::RandomParamSetOut() const +{ + uint32_t size = RandomUint32() % MAX_OUT_BLOB_SIZE; + if (size == 0) { + return nullptr; + } + struct HksParamSet *paramSet = (struct HksParamSet *)HksMalloc(size); + if (paramSet != nullptr) { + paramSet->paramSetSize = size; + paramSet->paramsCnt = 0; + } + return paramSet; +} + +struct HksKeyInfo *HuksFuzzTest::RandomKeyInfoOut() const +{ + if (RandomUint32() == 0) { + return nullptr; + } + + struct HksKeyInfo *keyInfo = (struct HksKeyInfo *)HksMalloc(sizeof(struct HksKeyInfo)); + if (keyInfo != nullptr) { + keyInfo->alias.size = 0; + keyInfo->alias.data = nullptr; + keyInfo->paramSet = RandomParamSetOut(); + } + + return keyInfo; +} + +struct HksCertChain *HuksFuzzTest::RandomCertChainOut() const +{ + if (RandomUint32() == 0) { + return nullptr; + } + + struct HksCertChain *certChain = (struct HksCertChain *)HksMalloc(sizeof(struct HksCertChain)); + if (certChain != nullptr) { + certChain->certs = nullptr; + certChain->certsCount = 0; + } + + return certChain; +} + +void HuksFuzzTest::HuksFuzzGenerateKey() const +{ + struct HksBlob *keyAlias = RandomBlob(HKS_MAX_KEY_ALIAS_LEN * 2); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksParamSet *paramSetOut = RandomParamSetOut(); + + HksGenerateKey(keyAlias, paramSetIn, paramSetOut); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (paramSetOut != nullptr) { + HksFreeParamSet(¶mSetOut); + } +} + +void HuksFuzzTest::HuksFuzzImportKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *key = RandomBlob(); + + HksImportKey(keyAlias, paramSetIn, key); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (key != nullptr) { + FreeBlob(key); + } +} + +void HuksFuzzTest::HuksFuzzGetSdkVersion() const +{ + struct HksBlob *sdkVersion = RandomBlob(); + + HksGetSdkVersion(sdkVersion); + + if (sdkVersion != nullptr) { + FreeBlob(sdkVersion); + } +} + +void HuksFuzzTest::HuksFuzzInitialize() const +{ + HksInitialize(); +} + +void HuksFuzzTest::HuksFuzzRefreshKeyInfo() const +{ + HksRefreshKeyInfo(); +} + +void HuksFuzzTest::HuksFuzzExportPublicKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *key = RandomBlob(); + + HksExportPublicKey(keyAlias, paramSetIn, key); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (key != nullptr) { + FreeBlob(key); + } +} + +void HuksFuzzTest::HuksFuzzDeleteKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + + HksDeleteKey(keyAlias, paramSetIn); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } +} + +void HuksFuzzTest::HuksFuzzGetKeyParamSet() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksParamSet *paramSetOut = RandomParamSetOut(); + + HksGetKeyParamSet(keyAlias, paramSetIn, paramSetOut); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (paramSetOut != nullptr) { + HksFreeParamSet(¶mSetOut); + } +} + +void HuksFuzzTest::HuksFuzzKeyExist() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + + HksKeyExist(keyAlias, paramSetIn); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } +} + +void HuksFuzzTest::HuksFuzzGenerateRandom() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *random = RandomBlob(); + + HksGenerateRandom(paramSetIn, random); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (random != nullptr) { + FreeBlob(random); + } +} + +void HuksFuzzTest::HuksFuzzSign() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *srcData = RandomBlob(); + struct HksBlob *signature = RandomBlob(); + + HksSign(key, paramSetIn, srcData, signature); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (srcData != nullptr) { + FreeBlob(srcData); + } + if (signature != nullptr) { + FreeBlob(signature); + } +} + +void HuksFuzzTest::HuksFuzzVerify() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *srcData = RandomBlob(); + struct HksBlob *signature = RandomBlob(); + + HksVerify(key, paramSetIn, srcData, signature); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (srcData != nullptr) { + FreeBlob(srcData); + } + if (signature != nullptr) { + FreeBlob(signature); + } +} + +void HuksFuzzTest::HuksFuzzEncrypt() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *plainText = RandomBlob(); + struct HksBlob *cipherText = RandomBlob(); + + HksEncrypt(key, paramSetIn, plainText, cipherText); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (plainText != nullptr) { + FreeBlob(plainText); + } + if (cipherText != nullptr) { + FreeBlob(cipherText); + } +} + +void HuksFuzzTest::HuksFuzzDecrypt() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *cipherText = RandomBlob(); + struct HksBlob *plainText = RandomBlob(); + + HksDecrypt(key, paramSetIn, cipherText, plainText); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (cipherText != nullptr) { + FreeBlob(cipherText); + } + if (plainText != nullptr) { + FreeBlob(plainText); + } +} + +void HuksFuzzTest::HuksFuzzAgreeKey() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *privateKey = RandomBlob(); + struct HksBlob *peerPublicKey = RandomBlob(); + struct HksBlob *agreedKey = RandomBlob(); + + HksAgreeKey(paramSetIn, privateKey, peerPublicKey, agreedKey); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (privateKey != nullptr) { + FreeBlob(privateKey); + } + if (peerPublicKey != nullptr) { + FreeBlob(peerPublicKey); + } + if (agreedKey != nullptr) { + FreeBlob(agreedKey); + } +} + +void HuksFuzzTest::HuksFuzzDeriveKey() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *mainKey = RandomBlob(); + struct HksBlob *derivedKey = RandomBlob(); + + HksDeriveKey(paramSetIn, mainKey, derivedKey); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (mainKey != nullptr) { + FreeBlob(mainKey); + } + if (derivedKey != nullptr) { + FreeBlob(derivedKey); + } +} + +void HuksFuzzTest::HuksFuzzMac() const +{ + struct HksBlob *key = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *srcData = RandomBlob(); + struct HksBlob *mac = RandomBlob(); + + HksMac(key, paramSetIn, srcData, mac); + + if (key != nullptr) { + FreeBlob(key); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (srcData != nullptr) { + FreeBlob(srcData); + } + if (mac != nullptr) { + FreeBlob(mac); + } +} + +void HuksFuzzTest::HuksFuzzHash() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *srcData = RandomBlob(); + struct HksBlob *hash = RandomBlob(); + + HksHash(paramSetIn, srcData, hash); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (srcData != nullptr) { + FreeBlob(srcData); + } + if (hash != nullptr) { + FreeBlob(hash); + } +} + +void HuksFuzzTest::HuksFuzzGetKeyInfoList() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksKeyInfo *keyInfoList = RandomKeyInfoOut(); + uint32_t listCount = RandomUint32(); + + HksGetKeyInfoList(paramSetIn, keyInfoList, &listCount); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (keyInfoList != nullptr) { + FreeKeyInfoOut(keyInfoList); + } +} + +void HuksFuzzTest::HuksFuzzAttestKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksCertChain *certChain = RandomCertChainOut(); + + HksAttestKey(keyAlias, paramSetIn, certChain); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (certChain != nullptr) { + FreeCertChainOut(certChain); + } +} + +void HuksFuzzTest::HuksFuzzGetCertificateChain() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksCertChain *certChain = RandomCertChainOut(); + + HksGetCertificateChain(keyAlias, paramSetIn, certChain); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (certChain != nullptr) { + FreeCertChainOut(certChain); + } +} + +void HuksFuzzTest::HuksFuzzWrapKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksBlob *targetKeyAlias = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + struct HksBlob *wrappedData = RandomBlob(); + + HksWrapKey(keyAlias, targetKeyAlias, paramSetIn, wrappedData); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (targetKeyAlias != nullptr) { + FreeBlob(targetKeyAlias); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } + if (wrappedData != nullptr) { + FreeBlob(wrappedData); + } +} + +void HuksFuzzTest::HuksFuzzUnwrapKey() const +{ + struct HksBlob *keyAlias = RandomBlob(); + struct HksBlob *targetKeyAlias = RandomBlob(); + struct HksBlob *wrappedData = RandomBlob(); + struct HksParamSet *paramSetIn = RandomParamSetIn(); + + HksUnwrapKey(keyAlias, targetKeyAlias, wrappedData, paramSetIn); + + if (keyAlias != nullptr) { + FreeBlob(keyAlias); + } + if (targetKeyAlias != nullptr) { + FreeBlob(targetKeyAlias); + } + if (wrappedData != nullptr) { + FreeBlob(wrappedData); + } + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } +} + +void HuksFuzzTest::HuksFuzzBnExpMod() const +{ + struct HksBlob *x = RandomBlob(); + struct HksBlob *a = RandomBlob(MAX_BYTES_BN); + struct HksBlob *e = RandomBlob(MAX_BYTES_BN); + struct HksBlob *n = RandomBlob(MAX_BYTES_BN); + + HksBnExpMod(x, a, e, n); + + if (x != nullptr) { + FreeBlob(x); + } + if (a != nullptr) { + FreeBlob(a); + } + if (e != nullptr) { + FreeBlob(e); + } + if (n != nullptr) { + FreeBlob(n); + } +} + +void HuksFuzzTest::HuksFuzzHcmIsDeviceKeyExist() const +{ + struct HksParamSet *paramSetIn = RandomParamSetIn(); + + HcmIsDeviceKeyExist(paramSetIn); + + if (paramSetIn != nullptr) { + HksFreeParamSet(¶mSetIn); + } +} + +/** + * @tc.number : HuksFuzzTest000 + * @tc.name : Huks fuzz test + * @tc.desc : Huks fuzz test + */ +HWTEST_F(HuksFuzzTest, HuksFuzzTest000, TestSize.Level1) +{ + auto expired = std::chrono::system_clock::now() + HUKS_FUZZ_TEST_TIME; + do { + RunFuzzTest(); + } while (std::chrono::system_clock::now() < expired); +} +} // namespace FuzzTest +} // namespace Huks +} // namespace Security +} // namespace OHOS \ No newline at end of file -- Gitee