From 51551bbaa926bdb45562b82d76dab4bade28753d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=BB=AB=E5=9C=B0=E5=AE=81=E5=AE=81?= <756090608@qq.com> Date: Thu, 5 Sep 2024 11:02:00 +0800 Subject: [PATCH 1/4] =?UTF-8?q?mini=E5=B9=B3=E5=8F=B0=E6=96=B0=E5=A2=9E?= =?UTF-8?q?=E6=8E=A5=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: guoxin <756090608@qq.com> --- BUILD.gn | 6 + bundle.json | 3 +- common/BUILD.gn | 63 ++++-- common/common.gni | 8 + common/inc/log.h | 11 +- frameworks/BUILD.gn | 86 +++++--- frameworks/crypto_operation/md.c | 11 + frameworks/crypto_operation/rand.c | 20 +- frameworks/frameworks.gni | 14 ++ frameworks/js/jsi/BUILD.gn | 45 ++++ frameworks/js/jsi/inc/jsi_api.h | 54 +++++ frameworks/js/jsi/inc/jsi_api_common.h | 43 ++++ frameworks/js/jsi/inc/jsi_api_errcode.h | 30 +++ frameworks/js/jsi/inc/jsi_list.h | 43 ++++ frameworks/js/jsi/inc/jsi_utils.h | 32 +++ frameworks/js/jsi/src/jsi_api.cpp | 39 ++++ frameworks/js/jsi/src/jsi_api_common.cpp | 31 +++ frameworks/js/jsi/src/jsi_api_errcode.cpp | 88 ++++++++ frameworks/js/jsi/src/jsi_list.cpp | 97 ++++++++ frameworks/js/jsi/src/jsi_md.cpp | 200 +++++++++++++++++ frameworks/js/jsi/src/jsi_rand.cpp | 160 ++++++++++++++ frameworks/js/jsi/src/jsi_utils.cpp | 91 ++++++++ frameworks/spi/rand_spi.h | 1 + plugin/BUILD.gn | 73 +++--- plugin/mbedtls_plugin/common/mbedtls_common.h | 30 +++ plugin/mbedtls_plugin/md/inc/mbedtls_md.h | 31 +++ plugin/mbedtls_plugin/md/src/mbedtls_md.c | 197 +++++++++++++++++ plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h | 29 +++ plugin/mbedtls_plugin/rand/src/mbedtls_rand.c | 208 ++++++++++++++++++ plugin/plugin.gni | 14 ++ 30 files changed, 1673 insertions(+), 85 deletions(-) create mode 100644 frameworks/js/jsi/BUILD.gn create mode 100644 frameworks/js/jsi/inc/jsi_api.h create mode 100644 frameworks/js/jsi/inc/jsi_api_common.h create mode 100644 frameworks/js/jsi/inc/jsi_api_errcode.h create mode 100644 frameworks/js/jsi/inc/jsi_list.h create mode 100644 frameworks/js/jsi/inc/jsi_utils.h create mode 100644 frameworks/js/jsi/src/jsi_api.cpp create mode 100644 frameworks/js/jsi/src/jsi_api_common.cpp create mode 100644 frameworks/js/jsi/src/jsi_api_errcode.cpp create mode 100644 frameworks/js/jsi/src/jsi_list.cpp create mode 100644 frameworks/js/jsi/src/jsi_md.cpp create mode 100644 frameworks/js/jsi/src/jsi_rand.cpp create mode 100644 frameworks/js/jsi/src/jsi_utils.cpp create mode 100644 plugin/mbedtls_plugin/common/mbedtls_common.h create mode 100644 plugin/mbedtls_plugin/md/inc/mbedtls_md.h create mode 100644 plugin/mbedtls_plugin/md/src/mbedtls_md.c create mode 100644 plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h create mode 100644 plugin/mbedtls_plugin/rand/src/mbedtls_rand.c diff --git a/BUILD.gn b/BUILD.gn index c7ff8f3..d8af064 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -24,6 +24,12 @@ group("crypto_framework_component") { "frameworks/native:ohcrypto", "plugin:crypto_openssl_plugin_lib", ] + } else if (os_level == "mini") { + deps = [ + "frameworks:crypto_framework_lib", + "frameworks/js/jsi:cryptoframework_jsi", + "plugin:crypto_mbedtls_plugin_lib", + ] } } diff --git a/bundle.json b/bundle.json index 3fe7bf3..e0f37ed 100644 --- a/bundle.json +++ b/bundle.json @@ -29,7 +29,8 @@ ], "features": [ "crypto_framework_enabled" ], "adapted_system_type": [ - "standard" + "standard", + "mini" ], "rom": "2048KB", "ram": "", diff --git a/common/BUILD.gn b/common/BUILD.gn index 965bd6c..98419d9 100644 --- a/common/BUILD.gn +++ b/common/BUILD.gn @@ -14,31 +14,46 @@ import("//base/security/crypto_framework/common/common.gni") import("//build/ohos.gni") -ohos_static_library("crypto_plugin_common") { - branch_protector_ret = "pac_ret" - subsystem_name = "security" - part_name = "crypto_framework" - include_dirs = crypto_framwork_common_inc_path - - sources = crypto_framwork_common_files - - if (os_level == "standard") { - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false +if (os_level == "standard") { + ohos_static_library("crypto_plugin_common") { + branch_protector_ret = "pac_ret" + subsystem_name = "security" + part_name = "crypto_framework" + include_dirs = crypto_framwork_common_inc_path + + sources = crypto_framwork_common_files + + if (os_level == "standard") { + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } } + defines = [ "HILOG_ENABLE" ] + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-Wall", + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + ] } +} else if (os_level == "mini") { + ohos_static_library("crypto_common_lite") { + subsystem_name = "security" + part_name = "crypto_framework" + include_dirs = crypto_framwork_common_inc_path + include_dirs += + [ "//base/hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite" ] - defines = [ "HILOG_ENABLE" ] - cflags = [ - "-DHILOG_ENABLE", - "-fPIC", - "-Wall", - ] - - external_deps = [ - "c_utils:utils", - "hilog:libhilog", - ] + sources = crypto_framwork_common_files_lite + + defines = [ "MINI_HILOG_ENABLE" ] + + configs = [ "${product_path}:product_public_configs" ] + } } diff --git a/common/common.gni b/common/common.gni index 5507276..b6c1865 100644 --- a/common/common.gni +++ b/common/common.gni @@ -30,3 +30,11 @@ framework_common_util_files = [ ] crypto_framwork_common_files = framework_common_util_files + +crypto_framwork_common_files_lite = [ + "//base/security/crypto_framework/common/src/blob.c", + "//base/security/crypto_framework/common/src/utils.c", + "//base/security/crypto_framework/common/src/log.c", + "//base/security/crypto_framework/common/src/memory.c", + "//base/security/crypto_framework/common/src/object_base.c", +] diff --git a/common/inc/log.h b/common/inc/log.h index 0a18450..563a38e 100644 --- a/common/inc/log.h +++ b/common/inc/log.h @@ -19,7 +19,16 @@ #include #include -#ifdef HILOG_ENABLE +#ifdef MINI_HILOG_ENABLE + +#include "hiview_log.h" + +#define LOGD(fmt, ...) HILOG_DEBUG(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) +#define LOGI(fmt, ...) HILOG_INFO(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) +#define LOGW(fmt, ...) HILOG_WARN(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) +#define LOGE(fmt, ...) HILOG_ERROR(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) + +#elif HILOG_ENABLE enum HcfLogLevel { HCF_LOG_LEVEL_I, diff --git a/frameworks/BUILD.gn b/frameworks/BUILD.gn index c861451..9d86409 100644 --- a/frameworks/BUILD.gn +++ b/frameworks/BUILD.gn @@ -24,37 +24,67 @@ config("framework_config") { ] } -ohos_shared_library("crypto_framework_lib") { - branch_protector_ret = "pac_ret" - subsystem_name = "security" - innerapi_tags = [ "platformsdk" ] - part_name = "crypto_framework" - public_configs = [ ":framework_config" ] - include_dirs = framework_inc_path + crypto_framwork_common_inc_path - - sources = framework_files - - if (os_level == "standard") { - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false +if (os_level == "standard") { + ohos_shared_library("crypto_framework_lib") { + branch_protector_ret = "pac_ret" + subsystem_name = "security" + innerapi_tags = [ "platformsdk" ] + part_name = "crypto_framework" + public_configs = [ ":framework_config" ] + include_dirs = framework_inc_path + crypto_framwork_common_inc_path + + sources = framework_files + + if (os_level == "standard") { + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } } + + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-Wall", + ] + + deps = [ + "../common:crypto_plugin_common", + "../plugin:crypto_openssl_plugin_lib", + ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + ] } +} else if (os_level == "mini") { + ohos_static_library("crypto_framework_lib") { + subsystem_name = "security" + part_name = "crypto_framework" + public_configs = [ ":framework_config" ] + include_dirs = framework_inc_lite_path + crypto_framwork_common_inc_path + include_dirs += + [ "//base/hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite" ] - cflags = [ - "-DHILOG_ENABLE", - "-fPIC", - "-Wall", - ] + sources = framework_lite_files - deps = [ - "../common:crypto_plugin_common", - "../plugin:crypto_openssl_plugin_lib", - ] + defines = [ + "CRYPTO_MBEDTLS", + "MINI_HILOG_ENABLE", + ] - external_deps = [ - "c_utils:utils", - "hilog:libhilog", - ] + deps = [ + "../common:crypto_common_lite", + "../plugin:crypto_mbedtls_plugin_lib", + ] + + configs = [ "${product_path}:product_public_configs" ] + + cflags = [ + "--diag_suppress", + "Pe188,Pe186", + ] + } } diff --git a/frameworks/crypto_operation/md.c b/frameworks/crypto_operation/md.c index 0a921fd..888f3be 100644 --- a/frameworks/crypto_operation/md.c +++ b/frameworks/crypto_operation/md.c @@ -19,7 +19,11 @@ #include "sym_key.h" #include "md_spi.h" +#ifdef CRYPTO_MBEDTLS +#include "mbedtls_md.h" +#else #include "md_openssl.h" +#endif #include "log.h" #include "config.h" @@ -43,6 +47,12 @@ typedef struct { } HcfMdAbility; static const HcfMdAbility MD_ABILITY_SET[] = { +#ifdef CRYPTO_MBEDTLS + { "SHA1", MbedtlsMdSpiCreate }, + { "SHA256", MbedtlsMdSpiCreate }, + { "SHA512", MbedtlsMdSpiCreate }, + { "MD5", MbedtlsMdSpiCreate }, +#else { "SHA1", OpensslMdSpiCreate }, { "SHA224", OpensslMdSpiCreate }, { "SHA256", OpensslMdSpiCreate }, @@ -50,6 +60,7 @@ static const HcfMdAbility MD_ABILITY_SET[] = { { "SHA512", OpensslMdSpiCreate }, { "MD5", OpensslMdSpiCreate }, { "SM3", OpensslMdSpiCreate }, +#endif }; static const char *GetMdClass(void) diff --git a/frameworks/crypto_operation/rand.c b/frameworks/crypto_operation/rand.c index 99018ad..0f4227d 100644 --- a/frameworks/crypto_operation/rand.c +++ b/frameworks/crypto_operation/rand.c @@ -18,7 +18,11 @@ #include #include #include "rand_spi.h" +#ifdef CRYPTO_MBEDTLS +#include "mbedtls_rand.h" +#else #include "rand_openssl.h" +#endif #include "log.h" #include "config.h" #include "memory.h" @@ -40,15 +44,19 @@ typedef struct { HcfRandSpiCreateFunc createSpiFunc; } HcfRandAbility; -static const HcfRandAbility RAND_ABILITY_SET[] = { - { "OpensslRand", HcfRandSpiCreate } -}; - static const char *GetRandClass(void) { return "Rand"; } +static const HcfRandAbility RAND_ABILITY_SET[] = { +#ifdef CRYPTO_MBEDTLS + { "MbedtlsRand", MbedtlsRandSpiCreate } +#else + { "OpensslRand", HcfRandSpiCreate } +#endif +}; + static HcfRandSpiCreateFunc FindAbility(const char *algoName) { for (uint32_t i = 0; i < (sizeof(RAND_ABILITY_SET) / sizeof(RAND_ABILITY_SET[0])); i++) { @@ -127,7 +135,11 @@ HcfResult HcfRandCreate(HcfRand **random) LOGE("Invalid input params while creating rand!"); return HCF_INVALID_PARAMS; } +#ifdef CRYPTO_MBEDTLS + HcfRandSpiCreateFunc createSpiFunc = FindAbility("MbedtlsRand"); +#else HcfRandSpiCreateFunc createSpiFunc = FindAbility("OpensslRand"); +#endif if (createSpiFunc == NULL) { LOGE("Algo not supported!"); return HCF_NOT_SUPPORT; diff --git a/frameworks/frameworks.gni b/frameworks/frameworks.gni index 623a379..957383a 100644 --- a/frameworks/frameworks.gni +++ b/frameworks/frameworks.gni @@ -65,3 +65,17 @@ framework_files = framework_cipher_files + framework_key_files + framework_mac_files + framework_rand_files + framework_md_files + framework_kdf_files + framework_sm2_crypto_util_files + +framework_inc_lite_path = [ + "${base_path}/interfaces/innerkits/algorithm_parameter", + "${base_path}/interfaces/innerkits/common", + "${base_path}/interfaces/innerkits/crypto_operation", + "${base_path}/interfaces/innerkits/key", + "${base_path}/common/inc", + "${plugin_path}/mbedtls_plugin/common", + "${plugin_path}/mbedtls_plugin/md/inc", + "${plugin_path}/mbedtls_plugin/rand/inc", + "${framework_path}/spi", +] + +framework_lite_files = framework_rand_files + framework_md_files diff --git a/frameworks/js/jsi/BUILD.gn b/frameworks/js/jsi/BUILD.gn new file mode 100644 index 0000000..6ac9a4c --- /dev/null +++ b/frameworks/js/jsi/BUILD.gn @@ -0,0 +1,45 @@ +# Copyright (C) 2024 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/crypto_framework/common/common.gni") +import("//base/security/crypto_framework/frameworks/frameworks.gni") +import("//build/lite/config/component/lite_component.gni") +import("//build/ohos.gni") + +ohos_static_library("cryptoframework_jsi") { + subsystem_name = "security" + part_name = "crypto_framework" + include_dirs = [ "inc" ] + include_dirs += framework_inc_path + include_dirs += [ + "../../../../../hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite", + ] + + sources = [ + "src/jsi_api.cpp", + "src/jsi_api_common.cpp", + "src/jsi_api_errcode.cpp", + "src/jsi_list.cpp", + "src/jsi_md.cpp", + "src/jsi_rand.cpp", + "src/jsi_utils.cpp", + ] + defines = [ "MINI_HILOG_ENABLE" ] + + deps = [ + "../../../common:crypto_common_lite", + "../../../frameworks:crypto_framework_lib", + ] + + configs = [ "${product_path}:product_public_configs" ] +} diff --git a/frameworks/js/jsi/inc/jsi_api.h b/frameworks/js/jsi/inc/jsi_api.h new file mode 100644 index 0000000..7234925 --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_api.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2024 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 JSI_API_H +#define JSI_API_H + +#include "jsi/jsi.h" +#include "jsi/jsi_types.h" + +namespace OHOS { +namespace ACELite { +class CryptoFrameworkLiteModule final : public MemoryHeap { +public: + CryptoFrameworkLiteModule() {} + ~CryptoFrameworkLiteModule() {}; + + static JSIValue CreateMd(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue CreateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static void OnDestroy(void); + +private: + // Md + static JSIValue Update(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue UpdateSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue Digest(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue DigestSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue GetMdLength(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + + // Random + static JSIValue GenerateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue GenerateRandomSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + static JSIValue SetSeed(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum); + + static void MdDestroy(void); + static void RandomDestroy(void); +}; + +void InitCryptoFrameworkModule(JSIValue exports); + +} // namespace ACELite +} // namespace OHOS +#endif // JSI_API_H diff --git a/frameworks/js/jsi/inc/jsi_api_common.h b/frameworks/js/jsi/inc/jsi_api_common.h new file mode 100644 index 0000000..e80dffb --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_api_common.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2024 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 JSI_API_COMMON_H +#define JSI_API_COMMON_H + +#include "jsi.h" +#include "jsi/jsi_types.h" + +#include "md.h" +#include "rand.h" +#include "object_base.h" + +namespace OHOS { +namespace ACELite { + +typedef enum { + JSI_ALG_MD = 1, + JSI_ALG_RAND = 2, + JSI_ALG_MAX +} LiteAlgType; + +#define ARRAY_MAX_SIZE 2 +#define ARRAY_INDEX_ZERO 0 +#define ARRAY_INDEX_ONE 1 + +void JsiAsyncCallback(const JSIValue thisVal, JSIValue args, const JSIValue *params, uint8_t paramsNum); + +} // namespace ACELite +} // namespace OHOS +#endif // JSI_API_COMMON_H diff --git a/frameworks/js/jsi/inc/jsi_api_errcode.h b/frameworks/js/jsi/inc/jsi_api_errcode.h new file mode 100644 index 0000000..6563a42 --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_api_errcode.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2024 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 JSI_API_ERRCODE_H +#define JSI_API_ERRCODE_H + +#include "jsi/jsi.h" +#include "jsi/jsi_types.h" + +namespace OHOS { +namespace ACELite { + +void CallbackErrorCodeOrDataResult(const JSIValue thisVal, const JSIValue args, int32_t errCode, const JSIValue data); +JSIValue ThrowErrorCodeResult(int32_t errorCode); + +} // namespace ACELite +} // namespace OHOS +#endif // JSI_API_ERRCODE_H diff --git a/frameworks/js/jsi/inc/jsi_list.h b/frameworks/js/jsi/inc/jsi_list.h new file mode 100644 index 0000000..06d2537 --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_list.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2024 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 JSI_LIST_H +#define JSI_LIST_H + +#include "los_list.h" +#include "jsi_api_common.h" + +namespace OHOS { +namespace ACELite { + +typedef struct { + LiteAlgType type; + LOS_DL_LIST *objListHeader; +} ListInfo; + +typedef struct { + LOS_DL_LIST listNode; + uint32_t objAddr; +} ObjList; + +void ListObjInit(LiteAlgType type); +HcfResult ListAddObjNode(LiteAlgType type, uint32_t addAddr); +void ListDeleteObjNode(LiteAlgType type, uint32_t deleteAddr); +void ListDestroy(LiteAlgType type); + +} // namespace ACELite +} // namespace OHOS + +#endif // JSI_LIST_H diff --git a/frameworks/js/jsi/inc/jsi_utils.h b/frameworks/js/jsi/inc/jsi_utils.h new file mode 100644 index 0000000..e3ee876 --- /dev/null +++ b/frameworks/js/jsi/inc/jsi_utils.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2024 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 JSI_UTILS_H +#define JSI_UTILS_H + +#include + +#include "blob.h" +#include "jsi_api_common.h" + +namespace OHOS { +namespace ACELite { + +HcfResult ParseUint8ArrayToBlob(JSIValue value, HcfBlob *blob); +JSIValue ConstructJSIReturnResult(const HcfBlob *blob); + +} // namespace ACELite +} // namespace OHOS +#endif // JSI_UTILS_H diff --git a/frameworks/js/jsi/src/jsi_api.cpp b/frameworks/js/jsi/src/jsi_api.cpp new file mode 100644 index 0000000..3312a0b --- /dev/null +++ b/frameworks/js/jsi/src/jsi_api.cpp @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2024 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 "jsi_api.h" +#include "jsi_list.h" +#include "jsi.h" + +namespace OHOS { +namespace ACELite { + +void InitCryptoFrameworkModule(JSIValue exports) +{ + JSI::SetModuleAPI(exports, "createMd", CryptoFrameworkLiteModule::CreateMd); + JSI::SetModuleAPI(exports, "createRandom", CryptoFrameworkLiteModule::CreateRandom); + JSI::SetOnDestroy(exports, CryptoFrameworkLiteModule::OnDestroy); + ListObjInit(JSI_ALG_MD); + ListObjInit(JSI_ALG_RAND); +} + +void CryptoFrameworkLiteModule::OnDestroy(void) +{ + RandomDestroy(); + MdDestroy(); +} + +} // ACELite +} // OHOS diff --git a/frameworks/js/jsi/src/jsi_api_common.cpp b/frameworks/js/jsi/src/jsi_api_common.cpp new file mode 100644 index 0000000..36db623 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_api_common.cpp @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2024 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 "jsi_api_common.h" +#include "jsi_api_errcode.h" + +namespace OHOS { +namespace ACELite { + +void JsiAsyncCallback(const JSIValue thisVal, const JSIValue args, const JSIValue *params, uint8_t paramsNum) +{ + JSIValue para[ARRAY_MAX_SIZE] = { params[ARRAY_INDEX_ZERO], params[ARRAY_INDEX_ONE] }; + JSI::CallFunction(args, thisVal, para, paramsNum); + JSI::ReleaseValue(para[ARRAY_INDEX_ZERO]); + JSI::ReleaseValue(para[ARRAY_INDEX_ONE]); +} + +} // namespace ACELite +} // namespace OHOS diff --git a/frameworks/js/jsi/src/jsi_api_errcode.cpp b/frameworks/js/jsi/src/jsi_api_errcode.cpp new file mode 100644 index 0000000..f9707bb --- /dev/null +++ b/frameworks/js/jsi/src/jsi_api_errcode.cpp @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2024 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 "jsi_api_errcode.h" +#include "jsi_api_common.h" + +namespace OHOS { +namespace ACELite { + +constexpr uint32_t JSI_ERR_CODE_DEFAULT_ERR = 0; +constexpr uint32_t JSI_ERR_CODE_OUT_OF_MEMORY = 17620001; +constexpr uint32_t JSI_ERR_CODE_RUNTIME_ERROR = 17620002; +constexpr uint32_t JSI_ERR_CODE_CRYPTO_OPERATION = 17630001; + +typedef struct { + uint32_t errorCode; + const char *errorMsg; +} JsiErrMsg; + +static JsiErrMsg g_errMsg[] = { + { JSI_ERR_CODE_PARAM_CHECK_FAILED, "Parameter error. Possible causes: 1. Mandatory parameters are left unspecified;\ + 2. Incorrect parameter types; 3. Parameter verification failed." }, + { JSI_ERR_CODE_NOT_SUPPORTED, "Capability not supported. Failed to call the API due to limited device\ + capabilities." }, + { JSI_ERR_CODE_OUT_OF_MEMORY, "memory error." }, + { JSI_ERR_CODE_RUNTIME_ERROR, "runtime error." }, + { JSI_ERR_CODE_CRYPTO_OPERATION, "crypto operation error." }, +}; + +static uint32_t GetJsiErrValueByErrCode(HcfResult errCode) +{ + switch (errCode) { + case HCF_INVALID_PARAMS: + return JSI_ERR_CODE_PARAM_CHECK_FAILED; + case HCF_NOT_SUPPORT: + return JSI_ERR_CODE_NOT_SUPPORTED; + case HCF_ERR_MALLOC: + return JSI_ERR_CODE_OUT_OF_MEMORY; + case HCF_ERR_NAPI: + return JSI_ERR_CODE_RUNTIME_ERROR; + case HCF_ERR_CRYPTO_OPERATION: + return JSI_ERR_CODE_CRYPTO_OPERATION; + default: + return JSI_ERR_CODE_DEFAULT_ERR; + } +} + +JSIValue ThrowErrorCodeResult(int32_t errCode) +{ + for (uint32_t index = 0; index < sizeof(g_errMsg) / sizeof(g_errMsg[0]); index++) { + if (g_errMsg[index].errorCode == GetJsiErrValueByErrCode((HcfResult)errCode)) { + return JSI::CreateErrorWithCode(g_errMsg[index].errorCode, g_errMsg[index].errorMsg); + } + } + + return JSI::CreateUndefined(); +} + +void CallbackErrorCodeOrDataResult(const JSIValue thisVal, const JSIValue args, int32_t errCode, const JSIValue data) +{ + for (uint32_t index = 0; index < sizeof(g_errMsg) /sizeof(g_errMsg[0]); index++) { + if (g_errMsg[index].errorCode == GetJsiErrValueByErrCode((HcfResult)errCode)) { + JSIValue errObj = JSI::CreateObject(); + JSI::SetNumberProperty(errObj, "code", g_errMsg[index].errorCode); + JSI::SetStringProperty(errObj, "message", g_errMsg[index].errorMsg); + JSIValue params[ARRAY_MAX_SIZE] = { errObj, data }; + JsiAsyncCallback(thisVal, args, params, ARRAY_MAX_SIZE); + return; + } + } + JSIValue params[ARRAY_MAX_SIZE] = { JSI::CreateUndefined(), data }; + JsiAsyncCallback(thisVal, args, params, ARRAY_MAX_SIZE); +} + +} // ACELite +} // OHOS diff --git a/frameworks/js/jsi/src/jsi_list.cpp b/frameworks/js/jsi/src/jsi_list.cpp new file mode 100644 index 0000000..14343b0 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_list.cpp @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2024 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 "jsi_list.h" +#include "memory.h" + +static LOS_DL_LIST g_mdObjListHeader = { 0 }; +static LOS_DL_LIST g_randObjListHeader = { 0 }; + +namespace OHOS { +namespace ACELite { + +ListInfo g_listMap[] = { + { JSI_ALG_MD, &g_mdObjListHeader }, + { JSI_ALG_RAND, &g_randObjListHeader } +}; + +LOS_DL_LIST *GetListHeader(LiteAlgType type) +{ + for (uint32_t index = 0; index < sizeof(g_listMap) / sizeof(g_listMap[0]); index++) { + if (type == g_listMap[index].type) { + return g_listMap[index].objListHeader; + } + } + + return nullptr; +} + +void ListObjInit(LiteAlgType type) +{ + LOS_ListInit(GetListHeader(type)); +} + +HcfResult ListAddObjNode(LiteAlgType type, uint32_t addAddr) +{ + ObjList *obj = (ObjList *)HcfMalloc(sizeof(ObjList), 0); + if (obj == nullptr) { + return HCF_ERR_MALLOC; + } + obj->objAddr = addAddr; + + if (GetListHeader(type)->pstNext == nullptr) { + LOS_ListInit(GetListHeader(type)); + } + LOS_ListAdd(GetListHeader(type), &(obj->listNode)); + + return HCF_SUCCESS; +} + +void ListDeleteObjNode(LiteAlgType type, uint32_t deleteAddr) +{ + ObjList *obj = nullptr; + ObjList *objNext = nullptr; + LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(obj, objNext, GetListHeader(type), ObjList, listNode) { + if (obj == nullptr) { + return; + } + if ((obj->objAddr != 0) && (obj->objAddr == deleteAddr)) { + LOS_ListDelete(&(obj->listNode)); + HcfObjDestroy((void *)deleteAddr); + obj->objAddr = 0; + HcfFree(obj); + obj = nullptr; + } + } +} + +void ListDestroy(LiteAlgType type) +{ + ObjList *obj = nullptr; + ObjList *objNext = nullptr; + uint32_t i = 0; + LOS_DL_LIST_FOR_EACH_ENTRY_SAFE(obj, objNext, GetListHeader(type), ObjList, listNode) { + if (obj == nullptr) { + return; + } + LOS_ListDelete(&(obj->listNode)); + HcfObjDestroy((void *)(obj->objAddr)); + HcfFree(obj); + obj = nullptr; + } +} + +} // ACELite +} // OHOS diff --git a/frameworks/js/jsi/src/jsi_md.cpp b/frameworks/js/jsi/src/jsi_md.cpp new file mode 100644 index 0000000..0d0d361 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_md.cpp @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2024 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 "jsi_api.h" +#include "jsi_api_common.h" +#include "jsi_api_errcode.h" +#include "jsi_utils.h" +#include "jsi_list.h" +#include "securec.h" +#include "log.h" + +namespace OHOS { +namespace ACELite { + +JSIValue CryptoFrameworkLiteModule::CreateMd(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("CreateMd args is err!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + char *alg = JSI::ValueToString(args[0]); + if (alg == nullptr) { + LOGE("Update alg is null!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + HcfMd *mdObj = nullptr; + HcfResult res = HcfMdCreate(reinterpret_cast(alg), &mdObj); + if (res != HCF_SUCCESS) { + LOGE("CreateMd is mdObj err res %d!", res); + return ThrowErrorCodeResult(res); + } + res = ListAddObjNode(JSI_ALG_MD, (uint32_t)mdObj); + if (res != HCF_SUCCESS) { + LOGE("md add node is %d err!", res); + HcfObjDestroy((void *)mdObj); + return ThrowErrorCodeResult(res); + } + + JSIValue serviceObj = JSI::CreateObject(); + JSIValue update = JSI::CreateFunction(Update); + JSIValue updateSync = JSI::CreateFunction(UpdateSync); + JSIValue digest = JSI::CreateFunction(Digest); + JSIValue digestSync = JSI::CreateFunction(DigestSync); + JSIValue getMdLength = JSI::CreateFunction(GetMdLength); + JSI::SetNamedProperty(serviceObj, "update", update); + JSI::SetNamedProperty(serviceObj, "updateSync", updateSync); + JSI::SetNamedProperty(serviceObj, "digest", digest); + JSI::SetNamedProperty(serviceObj, "digestSync", digestSync); + JSI::SetNamedProperty(serviceObj, "getMdLength", getMdLength); + JSI::SetNumberProperty(serviceObj, "mdObj", (double)(uint32_t)mdObj); + JSI::ReleaseValueList(update, updateSync, digest, digestSync, getMdLength, ARGS_END); + + return serviceObj; +} + +JSIValue CryptoFrameworkLiteModule::Update(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + if ((args == nullptr) || (argsNum != ARRAY_MAX_SIZE)) { + LOGE("Update args is null!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("Update mdObj is null!!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + + JSIValue inVlaue = JSI::GetNamedProperty(args[ARRAY_INDEX_ZERO], "data"); + HcfBlob inBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = ParseUint8ArrayToBlob(inVlaue, &inBlob); + if (errCode != HCF_SUCCESS) { + LOGE("Update inBlob is null!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + + errCode = mdObj->update(mdObj, &inBlob); + HcfBlobDataClearAndFree(&inBlob); + if (errCode != HCF_SUCCESS) { + LOGE("Update errCode not is success!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], errCode, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_SUCCESS, JSI::CreateNull()); + + return JSI::CreateUndefined(); +} + +JSIValue CryptoFrameworkLiteModule::UpdateSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("UpdateSync args is null!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("UpdateSync mdObj is null!!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + JSIValue inVlaue = JSI::GetNamedProperty(args[ARRAY_INDEX_ZERO], "data"); + HcfBlob inBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = ParseUint8ArrayToBlob(inVlaue, &inBlob); + if (errCode != HCF_SUCCESS) { + LOGE("UpdateSync inBlob is null!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateNull()); + return JSI::CreateUndefined(); + } + + errCode = mdObj->update(mdObj, &inBlob); + HcfBlobDataClearAndFree(&inBlob); + if (errCode != HCF_SUCCESS) { + LOGE("UpdateSync update ret is error!"); + } + + return ThrowErrorCodeResult(errCode); +} + +JSIValue CryptoFrameworkLiteModule::Digest(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("Digest args is err or mdObj nullptr!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("Digest mdObj is null!!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + HcfBlob outBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = mdObj->doFinal(mdObj, &outBlob); + if (errCode != HCF_SUCCESS) { + LOGE("Digest errCode not is success!"); + HcfBlobDataClearAndFree(&outBlob); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], errCode, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + JSIValue outVlaue = ConstructJSIReturnResult(&outBlob); + CallbackErrorCodeOrDataResult(thisVal, args[0], errCode, outVlaue); + HcfBlobDataClearAndFree(&outBlob); + + return JSI::CreateUndefined(); +} + +JSIValue CryptoFrameworkLiteModule::DigestSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("DigestSync mdObj is null!!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + HcfBlob outBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = mdObj->doFinal(mdObj, &outBlob); + if (errCode != HCF_SUCCESS) { + LOGE("DigestSync errCode not is success!"); + HcfBlobDataClearAndFree(&outBlob); + return ThrowErrorCodeResult(errCode); + } + + JSIValue mdSyncData = ConstructJSIReturnResult(&outBlob); + HcfBlobDataClearAndFree(&outBlob); + + return mdSyncData; +} + +JSIValue CryptoFrameworkLiteModule::GetMdLength(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfMd *mdObj = (HcfMd *)(uint32_t)JSI::GetNumberProperty(thisVal, "mdObj"); + if (mdObj == nullptr) { + LOGE("GetMdLength mdObj is null!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + return JSI::CreateNumber(mdObj->getMdLength(mdObj)); +} + +void CryptoFrameworkLiteModule::MdDestroy(void) +{ + ListDestroy(JSI_ALG_MD); +} + +} // namespace ACELite +} // namespace OHOS diff --git a/frameworks/js/jsi/src/jsi_rand.cpp b/frameworks/js/jsi/src/jsi_rand.cpp new file mode 100644 index 0000000..c1059e0 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_rand.cpp @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2024 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 "jsi_api.h" +#include "jsi_api_common.h" +#include "jsi_api_errcode.h" +#include "jsi_utils.h" +#include "jsi_list.h" +#include "securec.h" +#include "jsi.h" +#include "jsi_types.h" +#include "log.h" + +namespace OHOS { +namespace ACELite { + +JSIValue CryptoFrameworkLiteModule::CreateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfRand *randObj = nullptr; + HcfResult res = HcfRandCreate(&randObj); + if (res != HCF_SUCCESS) { + LOGE("CreateRandom is randObj err %d!", res); + return ThrowErrorCodeResult(res); + } + + res = ListAddObjNode(JSI_ALG_RAND, (uint32_t)randObj); + if (res != HCF_SUCCESS) { + LOGE("rand add node is %d err!", res); + HcfObjDestroy((void *)randObj); + return ThrowErrorCodeResult(res); + } + + JSIValue serviceObj = JSI::CreateObject(); + JSIValue generateRandom = JSI::CreateFunction(GenerateRandom); + JSIValue generateRandomSync = JSI::CreateFunction(GenerateRandomSync); + JSIValue setSeed = JSI::CreateFunction(SetSeed); + + JSI::SetNamedProperty(serviceObj, "generateRandom", generateRandom); + JSI::SetNamedProperty(serviceObj, "generateRandomSync", generateRandomSync); + JSI::SetNamedProperty(serviceObj, "setSeed", setSeed); + JSI::SetNumberProperty(serviceObj, "randObj", (double)(uint32_t)randObj); + JSI::ReleaseValueList(generateRandom, generateRandomSync, setSeed, ARGS_END); + + return serviceObj; +} + +JSIValue CryptoFrameworkLiteModule::GenerateRandom(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); + if (randObj == nullptr) { + LOGE("GenerateRandom randObj is null!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + if ((args == nullptr) || (argsNum != ARRAY_MAX_SIZE) || (args[ARRAY_INDEX_ONE] == nullptr)) { + LOGE("GenerateRandom params is err!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + + int32_t numBytes = (int32_t)JSI::ValueToNumber(args[0]); + if (numBytes <= 0) { + LOGE("GenerateRandom numBytes too small!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], HCF_INVALID_PARAMS, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + HcfBlob randBlob = { .data = nullptr, .len = 0 }; + HcfResult res = randObj->generateRandom(randObj, numBytes, &randBlob); + if (res != HCF_SUCCESS) { + LOGE("GenerateRandom randObj not is success!"); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], res, JSI::CreateUndefined()); + return JSI::CreateUndefined(); + } + + JSIValue outVlaue = ConstructJSIReturnResult(&randBlob); + CallbackErrorCodeOrDataResult(thisVal, args[ARRAY_INDEX_ONE], res, outVlaue); + HcfBlobDataClearAndFree(&randBlob); + + return JSI::CreateUndefined(); +} + +JSIValue CryptoFrameworkLiteModule::GenerateRandomSync(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); + if (randObj == nullptr) { + LOGE("GenerateRandom randObj is null!!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("GenerateRandomSync params is err"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + + int32_t numBytes = (int32_t)JSI::ValueToNumber(args[0]); + if (numBytes <= 0) { + LOGE("GenerateRandomSync numBytes too small!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + HcfBlob randBlob = { .data = nullptr, .len = 0 }; + HcfResult res = randObj->generateRandom(randObj, numBytes, &randBlob); + if (res != HCF_SUCCESS) { + LOGE("GenerateRandomSync randObj not is success!"); + HcfBlobDataClearAndFree(&randBlob); + return ThrowErrorCodeResult(res); + } + JSIValue randomSyncData = ConstructJSIReturnResult(&randBlob); + HcfBlobDataClearAndFree(&randBlob); + + return randomSyncData; +} + +JSIValue CryptoFrameworkLiteModule::SetSeed(const JSIValue thisVal, const JSIValue *args, uint8_t argsNum) +{ + HcfRand *randObj = (HcfRand *)(uint32_t)JSI::GetNumberProperty(thisVal, "randObj"); + if (randObj == nullptr) { + LOGE("SetSeed randObj is null!!"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + if ((args == nullptr) || (argsNum != ARRAY_INDEX_ONE)) { + LOGE("SetSeed params is null"); + return ThrowErrorCodeResult(HCF_INVALID_PARAMS); + } + JSIValue inVlaue = JSI::GetNamedProperty(args[ARRAY_INDEX_ZERO], "data"); + HcfBlob seedBlob = { .data = nullptr, .len = 0 }; + HcfResult errCode = ParseUint8ArrayToBlob(inVlaue, &seedBlob); + if (errCode != HCF_SUCCESS) { + LOGE("SetSeed seedBlob is null!"); + return ThrowErrorCodeResult(HCF_ERR_MALLOC); + } + + HcfResult res = randObj->setSeed(randObj, &seedBlob); + HcfBlobDataClearAndFree(&seedBlob); + if (res != HCF_SUCCESS) { + LOGE("setSeed randObj not is success!"); + return ThrowErrorCodeResult(res); + } + + return ThrowErrorCodeResult(HCF_SUCCESS); +} + +void CryptoFrameworkLiteModule::RandomDestroy(void) +{ + ListDestroy(JSI_ALG_RAND); +} + +} // namespace ACELite +} // namespace OHOS diff --git a/frameworks/js/jsi/src/jsi_utils.cpp b/frameworks/js/jsi/src/jsi_utils.cpp new file mode 100644 index 0000000..0cbbb46 --- /dev/null +++ b/frameworks/js/jsi/src/jsi_utils.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2024 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 "jsi_utils.h" +#include "jsi.h" +#include "jsi_types.h" +#include "memory.h" +#include "securec.h" +#include "utils.h" +#include "log.h" + +namespace OHOS { +namespace ACELite { + +HcfResult ParseUint8ArrayToBlob(JSIValue value, HcfBlob *blob) +{ + if (!JSI::ValueIsTypedArray(value) || (blob == nullptr)) { + LOGE("value is not a typed array!"); + return HCF_INVALID_PARAMS; + } + TypedArrayType arrayType; + size_t arraySize = 0; + size_t byteOffset = 0; + JSIValue arrayBuffer = nullptr; + uint8_t *dataArray; + HcfResult ret = HCF_SUCCESS; + do { + dataArray = JSI::GetTypedArrayInfo(value, arrayType, arraySize, arrayBuffer, byteOffset); + if (dataArray == nullptr) { + ret = HCF_ERR_CRYPTO_OPERATION; + break; + } + if (arrayType != TypedArrayType::JSI_UINT8_ARRAY) { + LOGE("value is not a uint8 array"); + ret = HCF_INVALID_PARAMS; + break; + } + blob->data = (uint8_t *)HcfMalloc(arraySize, 0); + if (blob->data == nullptr) { + ret = HCF_ERR_MALLOC; + break; + } + memcpy_s(blob->data, arraySize, dataArray + byteOffset, arraySize); + blob->len = arraySize; + } while (0); + if (arrayBuffer != nullptr) { + JSI::ReleaseValue(arrayBuffer); + arrayBuffer = nullptr; + } + return ret; +} + +JSIValue ConstructJSIReturnResult(const HcfBlob *blob) +{ + JSIValue res; + do { + res = JSI::CreateObject(); + if (res == nullptr) { + break; + } + if (blob->data != nullptr) { + uint8_t *arrayBuffer = nullptr; + JSIValue buffer = JSI::CreateArrayBuffer(blob->len, arrayBuffer); + if (arrayBuffer == nullptr) { + LOGE("create jsi array buffer failed"); + JSI::ReleaseValue(buffer); + return res; + } + (void)memcpy_s(arrayBuffer, blob->len, blob->data, blob->len); + JSIValue typedArray = JSI::CreateTypedArray(TypedArrayType::JSI_UINT8_ARRAY, blob->len, buffer, 0); + JSI::ReleaseValue(buffer); + JSI::SetNamedProperty(res, "data", typedArray); + } + } while (0); + return res; +} + +} // namespace ACELite +} // namespace OHOS diff --git a/frameworks/spi/rand_spi.h b/frameworks/spi/rand_spi.h index 8b554c6..166950f 100644 --- a/frameworks/spi/rand_spi.h +++ b/frameworks/spi/rand_spi.h @@ -22,6 +22,7 @@ #include "object_base.h" #define OPENSSL_RAND_ALGORITHM "CTR_DRBG" +#define MBEDTLS_RAND_ALGORITHM "CTR_DRBG_MBEDTLS" typedef struct HcfRandSpi HcfRandSpi; diff --git a/plugin/BUILD.gn b/plugin/BUILD.gn index 3c3e765..08b689c 100644 --- a/plugin/BUILD.gn +++ b/plugin/BUILD.gn @@ -25,36 +25,55 @@ config("plugin_config") { ] } -ohos_shared_library("crypto_openssl_plugin_lib") { - branch_protector_ret = "pac_ret" - subsystem_name = "security" - innerapi_tags = [ "platformsdk_indirect" ] - part_name = "crypto_framework" - public_configs = [ ":plugin_config" ] - include_dirs = plugin_inc_path + crypto_framwork_common_inc_path - - sources = plugin_files - - if (os_level == "standard") { - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false +if (os_level == "standard") { + ohos_shared_library("crypto_openssl_plugin_lib") { + branch_protector_ret = "pac_ret" + subsystem_name = "security" + innerapi_tags = [ "platformsdk_indirect" ] + part_name = "crypto_framework" + public_configs = [ ":plugin_config" ] + include_dirs = plugin_inc_path + crypto_framwork_common_inc_path + + sources = plugin_files + + if (os_level == "standard") { + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } } + + cflags = [ + "-DHILOG_ENABLE", + "-fPIC", + "-Wall", + ] + + deps = [ "//base/security/crypto_framework/common:crypto_plugin_common" ] + + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "openssl:libcrypto_shared", + ] + defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ] } +} else if (os_level == "mini") { + ohos_static_library("crypto_mbedtls_plugin_lib") { + subsystem_name = "security" + part_name = "crypto_framework" + public_configs = [ ":plugin_config" ] + include_dirs = crypto_framwork_common_inc_path + mbedtls_plugin_inc_path + include_dirs += + [ "//base/hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite" ] - cflags = [ - "-DHILOG_ENABLE", - "-fPIC", - "-Wall", - ] + sources = mbedtls_plugin_files - deps = [ "//base/security/crypto_framework/common:crypto_plugin_common" ] + defines = [ "MINI_HILOG_ENABLE" ] - external_deps = [ - "c_utils:utils", - "hilog:libhilog", - "openssl:libcrypto_shared", - ] - defines = [ "OPENSSL_SUPPRESS_DEPRECATED" ] + deps = [ "//base/security/crypto_framework/common:crypto_common_lite" ] + + configs = [ "${product_path}:product_public_configs" ] + } } diff --git a/plugin/mbedtls_plugin/common/mbedtls_common.h b/plugin/mbedtls_plugin/common/mbedtls_common.h new file mode 100644 index 0000000..702a39e --- /dev/null +++ b/plugin/mbedtls_plugin/common/mbedtls_common.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2024 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 MBEDTLS_COMMON_H +#define MBEDTLS_COMMON_H + +#include +#include + +#include "result.h" +#include "utils.h" + +#define HCF_MBEDTLS_SUCCESS 0 +#define HCF_MBEDTLS_FAILURE (-1) +#define HCF_BITS_PER_BYTE 8 +#define HCF_EVP_MAX_MD_SIZE 64 + +#endif diff --git a/plugin/mbedtls_plugin/md/inc/mbedtls_md.h b/plugin/mbedtls_plugin/md/inc/mbedtls_md.h new file mode 100644 index 0000000..cbd66da --- /dev/null +++ b/plugin/mbedtls_plugin/md/inc/mbedtls_md.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2024 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 HCF_MBEDTLS_MD_H +#define HCF_MBEDTLS_MD_H + +#include "md_spi.h" + +#define HCF_MBEDTLS_INVALID_MD_LEN 0 + +#ifdef __cplusplus +extern "C" { +#endif + +HcfResult MbedtlsMdSpiCreate(const char *mbedtlsAlgoName, HcfMdSpi **spiObj); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/plugin/mbedtls_plugin/md/src/mbedtls_md.c b/plugin/mbedtls_plugin/md/src/mbedtls_md.c new file mode 100644 index 0000000..73a5fd6 --- /dev/null +++ b/plugin/mbedtls_plugin/md/src/mbedtls_md.c @@ -0,0 +1,197 @@ +/* + * Copyright (C) 2024 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 "mbedtls_md.h" + +#include "mbedtls_common.h" +#include "mbedtls/md.h" +#include "securec.h" +#include "log.h" +#include "memory.h" +#include "config.h" +#include "utils.h" + +typedef struct { + HcfMdSpi base; + mbedtls_md_context_t *ctx; + char mbedtlsAlgoName[HCF_MAX_ALGO_NAME_LEN]; +} MbedtlsMdSpiImpl; + +mbedtls_md_context_t *MbedtlsEvpMdCtxNew(void) +{ + return (mbedtls_md_context_t *)HcfMalloc(sizeof(mbedtls_md_context_t), 0); +} + +void MbedtlsEvpMdCtxFree(mbedtls_md_context_t *ctx) +{ + HcfFree(ctx); +} + +static const char *MbedtlsGetMdClass(void) +{ + return "MbedtlsMd"; +} + +static mbedtls_md_context_t *MbedtlsGetMdCtx(HcfMdSpi *self) +{ + if (!HcfIsClassMatch((HcfObjectBase *)self, MbedtlsGetMdClass())) { + LOGE("Class is not match."); + return NULL; + } + + return ((MbedtlsMdSpiImpl *)self)->ctx; +} + +static HcfResult MbedtlsEngineUpdateMd(HcfMdSpi *self, HcfBlob *input) +{ + mbedtls_md_context_t *ctx = MbedtlsGetMdCtx(self); + if (ctx == NULL) { + LOGD("The CTX is NULL!"); + return HCF_INVALID_PARAMS; + } + int32_t ret = mbedtls_md_update(ctx, (const unsigned char *)input->data, input->len); + if (ret != HCF_MBEDTLS_SUCCESS) { + LOGD("EVP_DigestUpdate return error %d!", ret); + return HCF_ERR_CRYPTO_OPERATION; + } + + return HCF_SUCCESS; +} + +static HcfResult MbedtlsEngineDoFinalMd(HcfMdSpi *self, HcfBlob *output) +{ + if ((self == NULL) || (output == NULL)) { + LOGE("The input self ptr is NULL!"); + return HCF_INVALID_PARAMS; + } + mbedtls_md_context_t *ctx = MbedtlsGetMdCtx(self); + if (ctx == NULL) { + LOGE("The CTX is NULL!"); + return HCF_INVALID_PARAMS; + } + unsigned char outputBuf[HCF_EVP_MAX_MD_SIZE] = { 0 }; + uint8_t outputLen = mbedtls_md_get_size(mbedtls_md_info_from_ctx(ctx)); + if (outputLen == 0) { + LOGD("Failed to md get size is 0!"); + return HCF_ERR_CRYPTO_OPERATION; + } + int32_t ret = mbedtls_md_finish(ctx, outputBuf); + if (ret != HCF_MBEDTLS_SUCCESS) { + LOGD("Failed to md finish return error is %d!", ret); + return HCF_ERR_CRYPTO_OPERATION; + } + output->data = (uint8_t *)HcfMalloc(outputLen, 0); + if (output->data == NULL) { + LOGE("Failed to allocate output->data memory!"); + return HCF_ERR_MALLOC; + } + (void)memcpy_s(output->data, outputLen, outputBuf, outputLen); + output->len = outputLen; + + return HCF_SUCCESS; +} + +static uint32_t MbedtlsEngineGetMdLength(HcfMdSpi *self) +{ + mbedtls_md_context_t *ctx = MbedtlsGetMdCtx(self); + if (ctx == NULL) { + LOGD("The CTX is NULL!"); + return HCF_MBEDTLS_INVALID_MD_LEN; + } + uint8_t outputLen = mbedtls_md_get_size(mbedtls_md_info_from_ctx(ctx)); + if ((outputLen == 0) || (outputLen > HCF_EVP_MAX_MD_SIZE)) { + LOGD("Get the overflow path length is %d in mbedtls!", outputLen); + return HCF_MBEDTLS_INVALID_MD_LEN; + } + + return outputLen; +} + +static void MbedtlsDestroyMd(HcfObjectBase *self) +{ + if (self == NULL) { + LOGE("The input self ptr is NULL!"); + return; + } + if (!HcfIsClassMatch(self, MbedtlsGetMdClass())) { + LOGE("Class is not match."); + return; + } + if (MbedtlsGetMdCtx((HcfMdSpi *)self) != NULL) { + mbedtls_md_free(MbedtlsGetMdCtx((HcfMdSpi *)self)); + MbedtlsEvpMdCtxFree(MbedtlsGetMdCtx((HcfMdSpi *)self)); + } + HcfFree(self); +} + +typedef struct { + char *mdAlg; + mbedtls_md_type_t mdType; +} MdAlgTypeMap; + +static MdAlgTypeMap g_mdAlgMap[] = { + { "MD5", MBEDTLS_MD_MD5 }, + { "SHA1", MBEDTLS_MD_SHA1 }, + { "SHA256", MBEDTLS_MD_SHA256 }, + { "SHA512", MBEDTLS_MD_SHA512 }, +}; + +int MbedtlsEvpDigestInitEx(mbedtls_md_context_t *ctx, const char *mbedtlsAlgoName) +{ + for (uint32_t index = 0; index < sizeof(g_mdAlgMap) / sizeof(g_mdAlgMap[0]); index++) { + if (strcmp(g_mdAlgMap[index].mdAlg, mbedtlsAlgoName) == 0) { + mbedtls_md_init(ctx); + mbedtls_md_setup(ctx, mbedtls_md_info_from_type(g_mdAlgMap[index].mdType), 0); + mbedtls_md_starts(ctx); + return HCF_MBEDTLS_SUCCESS; + } + } + + return HCF_MBEDTLS_FAILURE; +} + +HcfResult MbedtlsMdSpiCreate(const char *mbedtlsAlgoName, HcfMdSpi **spiObj) +{ + if (spiObj == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + MbedtlsMdSpiImpl *returnSpiImpl = (MbedtlsMdSpiImpl *)HcfMalloc(sizeof(MbedtlsMdSpiImpl), 0); + if (returnSpiImpl == NULL) { + LOGE("Failed to allocate returnImpl memory!"); + return HCF_ERR_MALLOC; + } + returnSpiImpl->ctx = MbedtlsEvpMdCtxNew(); + if (returnSpiImpl->ctx == NULL) { + LOGE("Failed to create ctx!"); + HcfFree(returnSpiImpl); + return HCF_ERR_MALLOC; + } + int32_t ret = MbedtlsEvpDigestInitEx(returnSpiImpl->ctx, mbedtlsAlgoName); + if (ret != HCF_MBEDTLS_SUCCESS) { + LOGD("Failed to init MD ret is %d!", ret); + MbedtlsEvpMdCtxFree(returnSpiImpl->ctx); + HcfFree(returnSpiImpl); + return HCF_ERR_CRYPTO_OPERATION; + } + returnSpiImpl->base.base.getClass = MbedtlsGetMdClass; + returnSpiImpl->base.base.destroy = MbedtlsDestroyMd; + returnSpiImpl->base.engineUpdateMd = MbedtlsEngineUpdateMd; + returnSpiImpl->base.engineDoFinalMd = MbedtlsEngineDoFinalMd; + returnSpiImpl->base.engineGetMdLength = MbedtlsEngineGetMdLength; + *spiObj = (HcfMdSpi *)returnSpiImpl; + + return HCF_SUCCESS; +} diff --git a/plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h b/plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h new file mode 100644 index 0000000..3ce3920 --- /dev/null +++ b/plugin/mbedtls_plugin/rand/inc/mbedtls_rand.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2024 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 HCF_MBEDTLS_RAND_H +#define HCF_MBEDTLS_RAND_H + +#include "rand_spi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +HcfResult MbedtlsRandSpiCreate(HcfRandSpi **spiObj); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/plugin/mbedtls_plugin/rand/src/mbedtls_rand.c b/plugin/mbedtls_plugin/rand/src/mbedtls_rand.c new file mode 100644 index 0000000..247eb69 --- /dev/null +++ b/plugin/mbedtls_plugin/rand/src/mbedtls_rand.c @@ -0,0 +1,208 @@ +/* + * Copyright (C) 2024 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 "mbedtls_rand.h" + +#include "mbedtls/entropy.h" +#include "mbedtls/ctr_drbg.h" +#include "securec.h" +#include "log.h" +#include "memory.h" +#include "utils.h" + +typedef struct { + HcfRandSpi base; + mbedtls_entropy_context *entropy; + mbedtls_ctr_drbg_context *ctrDrbg; +} HcfRandSpiImpl; + +static const char *GetMbedtlsRandClass(void) +{ + return "RandMbedtls"; +} + +static mbedtls_entropy_context *MbedtlsGetMdEntropy(HcfRandSpi *self) +{ + if (!HcfIsClassMatch((HcfObjectBase *)self, GetMbedtlsRandClass())) { + LOGE("Class is not match."); + return NULL; + } + + return ((HcfRandSpiImpl *)self)->entropy; +} + +static mbedtls_ctr_drbg_context *MbedtlsGetMdCtrDrbg(HcfRandSpi *self) +{ + if (!HcfIsClassMatch((HcfObjectBase *)self, GetMbedtlsRandClass())) { + LOGE("Class is not match."); + return NULL; + } + return ((HcfRandSpiImpl *)self)->ctrDrbg; +} + +static HcfResult MbedtlsGenerateRandom(HcfRandSpi *self, int32_t numBytes, HcfBlob *random) +{ + if ((self == NULL) || (random == NULL)) { + LOGE("Invalid params!"); + return HCF_INVALID_PARAMS; + } + if (numBytes <= 0) { + LOGE("Invalid numBytes!"); + return HCF_INVALID_PARAMS; + } + mbedtls_ctr_drbg_context *ctrDrbg = MbedtlsGetMdCtrDrbg(self); + if (ctrDrbg == NULL) { + LOGE("Invalid ctrDrbg null!"); + return HCF_INVALID_PARAMS; + } + random->data = (uint8_t *)HcfMalloc(numBytes, 0); + if (random->data == NULL) { + LOGE("Failed to allocate random->data memory!"); + return HCF_ERR_MALLOC; + } + int32_t ret = mbedtls_ctr_drbg_random(ctrDrbg, random->data, numBytes); + if (ret != 0) { + LOGE("RAND_bytes return is %d error!", ret); + HcfFree(random->data); + random->data = NULL; + return HCF_ERR_CRYPTO_OPERATION; + } + random->len = numBytes; + + return HCF_SUCCESS; +} + +static const char *MbedtlsGetRandAlgoName(HcfRandSpi *self) +{ + if (self == NULL) { + LOGE("Invalid input parameter."); + return NULL; + } + if (!HcfIsClassMatch((HcfObjectBase *)self, GetMbedtlsRandClass())) { + LOGE("Class is not match."); + return NULL; + } + + return MBEDTLS_RAND_ALGORITHM; +} + +static void MbedtlsSetSeed(HcfRandSpi *self, HcfBlob *seed) +{ + if ((self == NULL) || (seed == NULL)) { + LOGE("Invalid params!"); + return; + } + if ((seed->data == NULL) || (seed->len == 0)) { + LOGE("Invalid numBytes!"); + return; + } + mbedtls_ctr_drbg_context *ctrDrbg = MbedtlsGetMdCtrDrbg(self); + if (ctrDrbg == NULL) { + LOGE("Invalid ctrDrbg params!"); + return; + } + mbedtls_entropy_context *entropy = MbedtlsGetMdEntropy(self); + if (entropy == NULL) { + LOGE("Invalid entropy params!"); + return; + } + int32_t ret = mbedtls_ctr_drbg_seed(ctrDrbg, mbedtls_entropy_func, entropy, + (const unsigned char *)seed->data, seed->len); + if (ret != 0) { + LOGE("seed return is %d error!", ret); + return; + } +} + +static void DestroyMbedtlsRand(HcfObjectBase *self) +{ + if (self == NULL) { + LOGE("Self ptr is NULL!"); + return; + } + if (!HcfIsClassMatch(self, GetMbedtlsRandClass())) { + LOGE("Class is not match."); + return; + } + mbedtls_ctr_drbg_context *ctrDrbg = MbedtlsGetMdCtrDrbg((HcfRandSpi *)self); + if (ctrDrbg != NULL) { + mbedtls_ctr_drbg_free(ctrDrbg); + HcfFree(ctrDrbg); + } + mbedtls_entropy_context *entropy = MbedtlsGetMdEntropy((HcfRandSpi *)self); + if (entropy != NULL) { + mbedtls_entropy_free(entropy); + HcfFree(entropy); + } + HcfFree(self); +} + +static int32_t MbedtlsRandInitEx(mbedtls_entropy_context **entropy, mbedtls_ctr_drbg_context **ctrDrbg) +{ + if ((entropy == NULL) || (ctrDrbg == NULL)) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + *entropy = (mbedtls_entropy_context *)HcfMalloc(sizeof(mbedtls_entropy_context), 0); + if (*entropy == NULL) { + LOGE("Failed to allocate *entropy memory!"); + return HCF_ERR_MALLOC; + } + *ctrDrbg = (mbedtls_ctr_drbg_context *)HcfMalloc(sizeof(mbedtls_ctr_drbg_context), 0); + if (*ctrDrbg == NULL) { + HcfFree(*entropy); + LOGE("Failed to allocate *ctrDrbg memory!"); + return HCF_ERR_MALLOC; + } + mbedtls_entropy_init(*entropy); + mbedtls_ctr_drbg_init(*ctrDrbg); + int32_t ret = mbedtls_ctr_drbg_seed(*ctrDrbg, mbedtls_entropy_func, *entropy, NULL, 0); + if (ret != 0) { + LOGE("Failed seed ret is %d!", ret); + mbedtls_entropy_free(*entropy); + mbedtls_ctr_drbg_free(*ctrDrbg); + HcfFree(*entropy); + HcfFree(*ctrDrbg); + return HCF_ERR_CRYPTO_OPERATION; + } + + return HCF_SUCCESS; +} + +HcfResult MbedtlsRandSpiCreate(HcfRandSpi **spiObj) +{ + if (spiObj == NULL) { + LOGE("Invalid input parameter."); + return HCF_INVALID_PARAMS; + } + HcfRandSpiImpl *returnSpiImpl = (HcfRandSpiImpl *)HcfMalloc(sizeof(HcfRandSpiImpl), 0); + if (returnSpiImpl == NULL) { + LOGE("Failed to allocate *returnSpiImpl memory!"); + return HCF_ERR_MALLOC; + } + int32_t ret = MbedtlsRandInitEx(&(returnSpiImpl->entropy), &(returnSpiImpl->ctrDrbg)); + if (ret != HCF_SUCCESS) { + LOGE("Failed to allocate entropy ctrDrbg memory!"); + return HCF_ERR_MALLOC; + } + returnSpiImpl->base.base.getClass = GetMbedtlsRandClass; + returnSpiImpl->base.base.destroy = DestroyMbedtlsRand; + returnSpiImpl->base.engineGenerateRandom = MbedtlsGenerateRandom; + returnSpiImpl->base.engineSetSeed = MbedtlsSetSeed; + returnSpiImpl->base.engineGetAlgoName = MbedtlsGetRandAlgoName; + *spiObj = (HcfRandSpi *)returnSpiImpl; + + return HCF_SUCCESS; +} diff --git a/plugin/plugin.gni b/plugin/plugin.gni index 8a18e7f..2d7f0d1 100644 --- a/plugin/plugin.gni +++ b/plugin/plugin.gni @@ -96,3 +96,17 @@ plugin_files = plugin_asy_key_generator_files + plugin_key_agreement_files + plugin_sym_key_files + plugin_cipher_files + plugin_hmac_files + plugin_rand_files + plugin_md_files + plugin_signature_files + plugin_common_files + plugin_kdf_files + +mbedtls_plugin_inc_path = [ + "${base_path}/interfaces/innerkits/common", + "${plugin_path}/mbedtls_plugin/common", + "${plugin_path}/mbedtls_plugin/md/inc", + "${plugin_path}/mbedtls_plugin/rand/inc", + "//base/security/crypto_framework/frameworks/spi", + "//base/security/crypto_framework/common/inc", +] + +mbedtls_plugin_files = [ + "${plugin_path}/mbedtls_plugin/md/src/mbedtls_md.c", + "${plugin_path}/mbedtls_plugin/rand/src/mbedtls_rand.c", +] -- Gitee From bc2323ece7437ff727c52f891a5735ba8e4d2c28 Mon Sep 17 00:00:00 2001 From: lcc Date: Sat, 7 Sep 2024 11:27:08 +0800 Subject: [PATCH 2/4] =?UTF-8?q?=E9=80=82=E9=85=8Dmini=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E6=9E=B6=E6=9E=84=E5=9B=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lcc --- .../zh-cn_crypto_framework_architecture.png | Bin 36019 -> 27719 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/figures/zh-cn_crypto_framework_architecture.png b/figures/zh-cn_crypto_framework_architecture.png index a35cc52b27ea1b2dfd68eb762a1d0dd102bdd68d..7c73e2ebd609c95d76c3f075b31ff45062190de6 100755 GIT binary patch literal 27719 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

`&pa}RxB~fb93Cdvd8G; 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�i*I^##fG|#Hs@h>1`N& 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 z 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 jqtGYp;WwN&aKM=Z98<>kz{Cmnawi==Z+>N%7c? -- Gitee From 43d973048d0035bf117015c70f2446cd60cbc7f9 Mon Sep 17 00:00:00 2001 From: lcc Date: Wed, 11 Sep 2024 10:17:13 +0800 Subject: [PATCH 3/4] =?UTF-8?q?README=E6=96=87=E4=BB=B6=E9=80=82=E9=85=8Dm?= =?UTF-8?q?ini=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lcc --- README_zh.md | 3 +++ common/inc/log.h | 4 ++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/README_zh.md b/README_zh.md index 7cad669..37a292d 100644 --- a/README_zh.md +++ b/README_zh.md @@ -21,14 +21,17 @@ base/security/crypto_framwork ├── test # unitest ├── common # 内部依赖的公共方法 ├── plugin # 算法适配的插件实现 +│ ├── mbedtls_plugin # mbedtls 插件 │ └── openssl_plugin # openssl 插件 ├── frameworks # 框架实现层 │ ├── spi # SPI的接口 │ ├── js +│ ├── jsi # 通过jsi封装的JS接口代码实现 │ └── napi # 通过napi封装的JS接口代码实现 │ ├── algorithm_parameter # 算法参数 │ ├── crypto_operation # 算法操作，包括mac、md、加解密、签名验签、秘钥协商 │ ├── key # 秘钥材料 +│ ├── native # 对外提供算法库C接口 │ └── rand # 随机数 ``` diff --git a/common/inc/log.h b/common/inc/log.h index 563a38e..ded8621 100644 --- a/common/inc/log.h +++ b/common/inc/log.h @@ -19,7 +19,7 @@ #include #include -#ifdef MINI_HILOG_ENABLE +#if defined(MINI_HILOG_ENABLE) #include "hiview_log.h" @@ -28,7 +28,7 @@ #define LOGW(fmt, ...) HILOG_WARN(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) #define LOGE(fmt, ...) HILOG_ERROR(HILOG_MODULE_SCY, fmt, ##__VA_ARGS__) -#elif HILOG_ENABLE +#elif defined(HILOG_ENABLE) enum HcfLogLevel { HCF_LOG_LEVEL_I, -- Gitee From 3b51040f748f82ec63a8cb23abd0f40c2b9a1c28 Mon Sep 17 00:00:00 2001 From: lcc Date: Sat, 14 Sep 2024 14:30:13 +0800 Subject: [PATCH 4/4] =?UTF-8?q?=E4=BF=AE=E6=94=B9TDD=E5=86=85=E5=AD=98?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lcc --- ...pto_dsa_asy_key_generator_by_spec_test.cpp | 2 +- .../src/crypto_dsa_asy_key_generator_test.cpp | 20 ++--- .../unittest/src/crypto_ecc_key_util_test.cpp | 42 ++++----- .../src/crypto_rsa_asy_key_generator_test.cpp | 2 - .../src/ecc/crypto_ecc_sign_sub_test.cpp | 4 + .../src/ecc/crypto_ecc_verify_sub_test.cpp | 2 + .../src/native/native_asym_key_test.cpp | 1 + .../src/native/native_sym_key_test.cpp | 1 + ...sm2_asy_key_generator_by_spec_sub_test.cpp | 45 ++++++++++ ...pto_sm2_asy_key_generator_by_spec_test.cpp | 86 +++++++++++++++++-- 10 files changed, 162 insertions(+), 43 deletions(-) diff --git a/test/unittest/src/crypto_dsa_asy_key_generator_by_spec_test.cpp b/test/unittest/src/crypto_dsa_asy_key_generator_by_spec_test.cpp index 98e0668..a756173 100644 --- a/test/unittest/src/crypto_dsa_asy_key_generator_by_spec_test.cpp +++ b/test/unittest/src/crypto_dsa_asy_key_generator_by_spec_test.cpp @@ -308,7 +308,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest1 const char *className = generator->base.getClass(); HcfObjDestroy(generator); - ASSERT_EQ(className, g_asyKeyGeneratorBySpecClass); + ASSERT_EQ(&className, &g_asyKeyGeneratorBySpecClass); } HWTEST_F(CryptoDsaAsyKeyGeneratorBySpecTest, CryptoDsaAsyKeyGeneratorBySpecTest102, TestSize.Level0) diff --git a/test/unittest/src/crypto_dsa_asy_key_generator_test.cpp b/test/unittest/src/crypto_dsa_asy_key_generator_test.cpp index 6257d41..50393d4 100644 --- a/test/unittest/src/crypto_dsa_asy_key_generator_test.cpp +++ b/test/unittest/src/crypto_dsa_asy_key_generator_test.cpp @@ -292,7 +292,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest203, TestSize HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest301, TestSize.Level0) { const char *className = dsa2048KeyPair_->base.getClass(); - ASSERT_EQ(className, OPENSSL_DSA_KEYPAIR_CLASS); + EXPECT_STREQ(className, OPENSSL_DSA_KEYPAIR_CLASS); } HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest302, TestSize.Level0) @@ -319,7 +319,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest305, TestSize dsa2048KeyPair_->base.destroy((HcfObjectBase *)&g_obj); const char *pkClassName = dsa2048KeyPair_->pubKey->base.base.getClass(); - ASSERT_EQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS); + EXPECT_STREQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS); } HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest306, TestSize.Level0) @@ -348,7 +348,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest309, TestSize dsa2048KeyPair_->pubKey->base.base.destroy((HcfObjectBase *)&g_obj); const char *alg = dsa2048KeyPair_->pubKey->base.getAlgorithm(&(dsa2048KeyPair_->pubKey->base)); - ASSERT_EQ(alg, g_algNameDSA); + EXPECT_STREQ(alg, g_algNameDSA); } HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest310, TestSize.Level1) @@ -475,7 +475,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest323, TestSize HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest324, TestSize.Level0) { const char *skClassName = dsa2048KeyPair_->priKey->base.base.getClass(); - ASSERT_EQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS); + EXPECT_STREQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS); } HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest325, TestSize.Level0) @@ -501,7 +501,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest325, TestSize HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest326, TestSize.Level0) { const char *alg = dsa2048KeyPair_->priKey->base.getAlgorithm(&(dsa2048KeyPair_->priKey->base)); - ASSERT_EQ(alg, g_algNameDSA); + EXPECT_STREQ(alg, g_algNameDSA); } HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest327, TestSize.Level0) @@ -675,7 +675,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest501, TestSize EXPECT_NE(convertKeyPair, nullptr); const char *keyPairClassName = convertKeyPair->base.getClass(); - EXPECT_EQ(keyPairClassName, OPENSSL_DSA_KEYPAIR_CLASS); + EXPECT_STREQ(keyPairClassName, OPENSSL_DSA_KEYPAIR_CLASS); HcfObjDestroy(generator); HcfObjDestroy(convertKeyPair); @@ -718,7 +718,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest503, TestSize EXPECT_NE(convertKeyPair, nullptr); const char *pkClassName = convertKeyPair->pubKey->base.base.getClass(); - EXPECT_EQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS); + EXPECT_STREQ(pkClassName, OPENSSL_DSA_PUBKEY_CLASS); HcfObjDestroy(generator); HcfObjDestroy(convertKeyPair); @@ -764,7 +764,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest505, TestSize EXPECT_NE(convertKeyPair, nullptr); const char *alg = convertKeyPair->pubKey->base.getAlgorithm(&(convertKeyPair->pubKey->base)); - EXPECT_EQ(alg, g_algNameDSA); + EXPECT_STREQ(alg, g_algNameDSA); HcfObjDestroy(generator); HcfObjDestroy(convertKeyPair); @@ -944,7 +944,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest512, TestSize EXPECT_NE(convertKeyPair, nullptr); const char *skClassName = convertKeyPair->priKey->base.base.getClass(); - EXPECT_EQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS); + EXPECT_STREQ(skClassName, OPENSSL_DSA_PRIKEY_CLASS); HcfObjDestroy(generator); HcfObjDestroy(convertKeyPair); @@ -989,7 +989,7 @@ HWTEST_F(CryptoDsaAsyKeyGeneratorTest, CryptoDsaAsyKeyGeneratorTest514, TestSize EXPECT_NE(convertKeyPair, nullptr); const char *skAlg = convertKeyPair->priKey->base.getAlgorithm(&(convertKeyPair->priKey->base)); - EXPECT_EQ(skAlg, g_algNameDSA); + EXPECT_STREQ(skAlg, g_algNameDSA); HcfObjDestroy(generator); HcfObjDestroy(convertKeyPair); diff --git a/test/unittest/src/crypto_ecc_key_util_test.cpp b/test/unittest/src/crypto_ecc_key_util_test.cpp index 6590e0a..77b8709 100644 --- a/test/unittest/src/crypto_ecc_key_util_test.cpp +++ b/test/unittest/src/crypto_ecc_key_util_test.cpp @@ -96,7 +96,7 @@ HcfObjectBase g_obj = { HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_1, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP160r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -106,7 +106,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_1, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_2, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP160t1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -116,7 +116,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_2, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_3, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP192r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -126,7 +126,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_3, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_4, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP192t1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -136,7 +136,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_4, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_5, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP224r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -146,7 +146,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_5, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_6, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP224t1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -156,7 +156,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_6, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_7, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP256r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -166,7 +166,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_7, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_8, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP256t1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -176,7 +176,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_8, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_9, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP320r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -186,7 +186,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_9, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_10, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP320t1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -196,7 +196,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_10, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_11, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP384r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -206,7 +206,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_11, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_12, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP384t1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -216,7 +216,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_12, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_13, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP512r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -226,7 +226,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_13, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_14, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_brainpoolP512t1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -236,7 +236,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_14, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_15, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_secp224r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -246,7 +246,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_15, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_16, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_X9_62_prime256v1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -256,7 +256,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_16, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_17, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_secp384r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -266,7 +266,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_17, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_18, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_secp521r1", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -276,7 +276,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_18, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_19, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("NID_sm2", &returnCommonParamSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(returnCommonParamSpec, nullptr); @@ -286,7 +286,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest001_19, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest002, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate(nullptr, &returnCommonParamSpec); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(returnCommonParamSpec, nullptr); @@ -302,7 +302,7 @@ HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest003, TestSize.Level0) HWTEST_F(CryptoEccKeyUtilTest, CryptoEccKeyUtilTest004, TestSize.Level0) { - HcfEccCommParamsSpec *returnCommonParamSpec; + HcfEccCommParamsSpec *returnCommonParamSpec = nullptr; HcfResult res = HcfEccKeyUtilCreate("BrainPoolP999", &returnCommonParamSpec); ASSERT_NE(res, HCF_SUCCESS); ASSERT_EQ(returnCommonParamSpec, nullptr); diff --git a/test/unittest/src/crypto_rsa_asy_key_generator_test.cpp b/test/unittest/src/crypto_rsa_asy_key_generator_test.cpp index c5b99a0..bfbea49 100644 --- a/test/unittest/src/crypto_rsa_asy_key_generator_test.cpp +++ b/test/unittest/src/crypto_rsa_asy_key_generator_test.cpp @@ -470,8 +470,6 @@ HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest511, TestSize EXPECT_NE(res, HCF_SUCCESS); HcfObjDestroy(keyPair); HcfObjDestroy(generator); - HcfFree(pubKeyBlob.data); - HcfFree(priKeyBlob.data); } HWTEST_F(CryptoRsaAsyKeyGeneratorTest, CryptoRsaAsyKeyGeneratorTest512, TestSize.Level0) diff --git a/test/unittest/src/ecc/crypto_ecc_sign_sub_test.cpp b/test/unittest/src/ecc/crypto_ecc_sign_sub_test.cpp index c557a31..2dfeea0 100644 --- a/test/unittest/src/ecc/crypto_ecc_sign_sub_test.cpp +++ b/test/unittest/src/ecc/crypto_ecc_sign_sub_test.cpp @@ -997,6 +997,7 @@ HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest927, TestSize.Level0) HcfFree(out.data); HcfObjDestroy(sign); + HcfObjDestroy(keyPair); } HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest928, TestSize.Level0) @@ -1038,6 +1039,7 @@ HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest928, TestSize.Level0) HcfFree(out.data); HcfObjDestroy(sign); + HcfObjDestroy(keyPair); } HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1001, TestSize.Level0) @@ -1323,6 +1325,7 @@ HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1101, TestSize.Level0) HcfFree(out.data); HcfObjDestroy(sign); + HcfObjDestroy(keyPair); uint32_t mallocCount = GetMallocNum(); MemoryMallocTestFunc(mallocCount, &input); @@ -1417,6 +1420,7 @@ HWTEST_F(CryptoEccSignSubTest, CryptoEccSignSubTest1102, TestSize.Level0) HcfFree(out.data); HcfObjDestroy(sign); + HcfObjDestroy(keyPair); uint32_t mallocCount = GetOpensslCallNum(); OpensslMockTestFunc(mallocCount, &input); diff --git a/test/unittest/src/ecc/crypto_ecc_verify_sub_test.cpp b/test/unittest/src/ecc/crypto_ecc_verify_sub_test.cpp index 385624d..689d510 100644 --- a/test/unittest/src/ecc/crypto_ecc_verify_sub_test.cpp +++ b/test/unittest/src/ecc/crypto_ecc_verify_sub_test.cpp @@ -1902,6 +1902,7 @@ HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest601, TestSize.Level0) ASSERT_EQ(flag, true); HcfObjDestroy(verify); + OH_Crypto_FreeDataBlob(&out); uint32_t mallocCount = GetMallocNum(); MemoryMockTestFunc(mallocCount, &out); @@ -1960,6 +1961,7 @@ HWTEST_F(CryptoEccVerifySubTest, CryptoEccVerifySubTest602, TestSize.Level0) uint32_t mallocCount = GetOpensslCallNum(); OpensslMockTestFunc(mallocCount, &out); + OH_Crypto_FreeDataBlob(&out); EndRecordOpensslCallNum(); } } diff --git a/test/unittest/src/native/native_asym_key_test.cpp b/test/unittest/src/native/native_asym_key_test.cpp index fc0dea1..f949d65 100644 --- a/test/unittest/src/native/native_asym_key_test.cpp +++ b/test/unittest/src/native/native_asym_key_test.cpp @@ -173,6 +173,7 @@ HWTEST_F(NativeAsymKeyTest, NativeAsymKeyTest004, TestSize.Level0) OH_CryptoAsymKeyGenerator_Destroy(ctx); OH_CryptoKeyPair_Destroy(keyPair); + OH_Crypto_FreeDataBlob(&retBlob); OH_CryptoKeyPair_Destroy(dupKeyPair); } diff --git a/test/unittest/src/native/native_sym_key_test.cpp b/test/unittest/src/native/native_sym_key_test.cpp index 79bc861..4730d88 100644 --- a/test/unittest/src/native/native_sym_key_test.cpp +++ b/test/unittest/src/native/native_sym_key_test.cpp @@ -79,6 +79,7 @@ HWTEST_F(NativeSymKeyTest, NativeSymKeyTest002, TestSize.Level0) ASSERT_NE(algoName, nullptr); OH_CryptoSymKey_Destroy(symKey); + OH_Crypto_FreeDataBlob(&dataBlob); OH_CryptoSymKeyGenerator_Destroy(ctx); } } \ No newline at end of file diff --git a/test/unittest/src/sm2/crypto_sm2_asy_key_generator_by_spec_sub_test.cpp b/test/unittest/src/sm2/crypto_sm2_asy_key_generator_by_spec_sub_test.cpp index 9d9e456..2a726e2 100644 --- a/test/unittest/src/sm2/crypto_sm2_asy_key_generator_by_spec_sub_test.cpp +++ b/test/unittest/src/sm2/crypto_sm2_asy_key_generator_by_spec_sub_test.cpp @@ -123,6 +123,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfFree(blob.data); HcfObjDestroy(pubKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); } @@ -150,6 +151,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(pubKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); } @@ -174,6 +176,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -198,6 +201,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -219,6 +223,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe ASSERT_NE(res, HCF_SUCCESS); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -240,6 +245,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe ASSERT_NE(res, HCF_SUCCESS); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -267,6 +273,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -291,6 +298,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe priKey->base.base.destroy((HcfObjectBase *)(&(priKey->base.base))); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -317,6 +325,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest075, TestSize.Level0) @@ -341,6 +350,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe priKey->base.base.destroy(&g_obj); HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -368,6 +378,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -393,6 +404,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe priKey->clearMem(priKey); HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -418,6 +430,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe priKey->clearMem(nullptr); HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -445,6 +458,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -472,6 +486,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -499,6 +514,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -526,6 +542,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -553,6 +570,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -581,6 +599,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest085, TestSize.Level0) @@ -610,6 +629,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfFree(blob.data); HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -642,6 +662,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfFree(blob.data); HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -673,6 +694,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfFree(blob.data); HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -700,6 +722,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); } @@ -753,6 +776,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(outKeyPair); HcfObjDestroy(generator); HcfObjDestroy(generatorBySpec); + HcfFree(g_eccCommSpec); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); } @@ -802,6 +826,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(keyPair); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); } @@ -861,6 +886,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(keyPair); HcfObjDestroy(generator); + HcfFree(g_eccCommSpec); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); } @@ -889,7 +915,9 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe ASSERT_EQ(res, HCF_SUCCESS); HcfObjDestroy(spiObj); + HcfObjDestroy(keyPair); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest093, TestSize.Level0) @@ -917,7 +945,9 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe ASSERT_EQ(res, HCF_SUCCESS); HcfObjDestroy(spiObj); + HcfObjDestroy(pubKey); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest094, TestSize.Level0) @@ -945,7 +975,9 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe ASSERT_EQ(res, HCF_SUCCESS); HcfObjDestroy(spiObj); + HcfObjDestroy(priKey); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest095, TestSize.Level0) @@ -972,7 +1004,9 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe ASSERT_EQ(res, HCF_SUCCESS); HcfObjDestroy(spiObj); + HcfObjDestroy(keyPair); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest096, TestSize.Level0) @@ -1005,6 +1039,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(priKey); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest097, TestSize.Level0) @@ -1034,6 +1069,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest098, TestSize.Level0) @@ -1056,6 +1092,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe res = keyPair->priKey->getAsyKeySpecString(keyPair->priKey, item, &retStr); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(retStr, nullptr); + HcfFree(retStr); retStr = nullptr; res = keyPair->pubKey->getAsyKeySpecString(keyPair->pubKey, item, &retStr); ASSERT_EQ(res, HCF_SUCCESS); @@ -1064,6 +1101,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(keyPair); HcfObjDestroy(generator); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest099, TestSize.Level0) @@ -1088,6 +1126,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(keyPair); HcfObjDestroy(generator); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest100, TestSize.Level0) @@ -1122,6 +1161,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTest101, TestSize.Level0) @@ -1155,6 +1195,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } static HcfResult ConstructSm2256KeyPairParamsSpecByGet(HcfEccKeyPairParamsSpec *eccKeyPairSpec, @@ -1273,6 +1314,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe HcfObjDestroy(generator); HcfObjDestroy(generatorSpec); FreeEccCommParamsSpec(reinterpret_cast(g_eccCommSpec)); + HcfFree(g_eccCommSpec); } static void OpensslMockTestFunc(uint32_t mallocCount, HcfAsyKeyParamsSpec *paramSpec) @@ -1359,6 +1401,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe uint32_t mallocCount = GetOpensslCallNum(); OpensslMockTestFunc(mallocCount, paramSpec); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); EndRecordOpensslCallNum(); } @@ -1410,6 +1453,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe uint32_t mallocCount = GetOpensslCallNum(); OpensslMockTestFunc1(mallocCount, paramSpec); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); EndRecordOpensslCallNum(); } @@ -1462,6 +1506,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecSubTest, CryptoSm2AsyKeyGeneratorBySpecTe uint32_t mallocCount = GetOpensslCallNum(); OpensslMockTestFunc2(mallocCount, paramSpec); DestroyEccPriKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); EndRecordOpensslCallNum(); } diff --git a/test/unittest/src/sm2/crypto_sm2_asy_key_generator_by_spec_test.cpp b/test/unittest/src/sm2/crypto_sm2_asy_key_generator_by_spec_test.cpp index c86b00c..c1aae3c 100644 --- a/test/unittest/src/sm2/crypto_sm2_asy_key_generator_by_spec_test.cpp +++ b/test/unittest/src/sm2/crypto_sm2_asy_key_generator_by_spec_test.cpp @@ -102,6 +102,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(generator); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest002, TestSize.Level0) @@ -127,6 +128,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, nullptr); ASSERT_NE(res, HCF_SUCCESS); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest004, TestSize.Level0) @@ -148,6 +150,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(generator); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest005, TestSize.Level0) @@ -166,6 +169,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 generator->base.destroy((HcfObjectBase *)generator); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest006, TestSize.Level0) @@ -185,6 +189,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 generator->base.destroy(nullptr); HcfObjDestroy(generator); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest007, TestSize.Level0) @@ -203,6 +208,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 generator->base.destroy(&g_obj); HcfObjDestroy(generator); + FreeAsyKeySpec(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest008, TestSize.Level0) @@ -223,6 +229,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(generator); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest009, TestSize.Level0) @@ -243,6 +250,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 ASSERT_EQ(algName, nullptr); HcfObjDestroy(generator); + FreeAsyKeySpec(paramSpec); } @@ -264,6 +272,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(generator); FreeEccCommParamsSpec(reinterpret_cast(paramSpec)); + HcfFree(paramSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest011, TestSize.Level0) @@ -288,14 +297,16 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest012, TestSize.Level0) { - ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec); - ASSERT_NE(g_eccCommSpec, nullptr); + HcfEccCommParamsSpec *eccCommSpec = nullptr; + ConstructEccKeyPairCommParamsSpec("NID_sm2", &eccCommSpec); + ASSERT_NE(eccCommSpec, nullptr); HcfAsyKeyParamsSpec *paramSpec = nullptr; - HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, ¶mSpec); + HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), eccCommSpec, ¶mSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(paramSpec, nullptr); @@ -314,6 +325,8 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); + FreeAsyKeySpec(paramSpec); + HcfFree(eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest013, TestSize.Level0) @@ -335,6 +348,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest014, TestSize.Level0) @@ -356,6 +370,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest015, TestSize.Level0) @@ -383,6 +398,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest016, TestSize.Level0) @@ -407,6 +423,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 keyPair->base.destroy((HcfObjectBase *)(&(keyPair->base))); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest017, TestSize.Level0) @@ -432,6 +449,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest018, TestSize.Level0) @@ -457,6 +475,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest019, TestSize.Level0) @@ -484,6 +503,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest020, TestSize.Level0) @@ -511,6 +531,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } @@ -537,6 +558,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } @@ -563,14 +585,16 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest023, TestSize.Level0) { - ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec); - ASSERT_NE(g_eccCommSpec, nullptr); + HcfEccCommParamsSpec *eccCommSpec = nullptr; + ConstructEccKeyPairCommParamsSpec("NID_sm2", &eccCommSpec); + ASSERT_NE(eccCommSpec, nullptr); HcfAsyKeyParamsSpec *paramSpec = nullptr; - HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, ¶mSpec); + HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), eccCommSpec, ¶mSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(paramSpec, nullptr); @@ -590,6 +614,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest024, TestSize.Level0) @@ -617,6 +642,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } @@ -645,6 +671,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } @@ -673,6 +700,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest027, TestSize.Level0) @@ -700,6 +728,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest028, TestSize.Level0) @@ -727,6 +756,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest029, TestSize.Level0) @@ -758,6 +788,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest030, TestSize.Level0) @@ -789,6 +820,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest031, TestSize.Level0) @@ -820,6 +852,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest032, TestSize.Level0) @@ -847,6 +880,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest033, TestSize.Level0) @@ -872,6 +906,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest034, TestSize.Level0) @@ -897,6 +932,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest035, TestSize.Level0) @@ -921,6 +957,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest036, TestSize.Level0) @@ -948,6 +985,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest037, TestSize.Level0) @@ -974,15 +1012,17 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest038, TestSize.Level0) { - ConstructEccKeyPairCommParamsSpec("NID_sm2", &g_eccCommSpec); - ASSERT_NE(g_eccCommSpec, nullptr); + HcfEccCommParamsSpec *eccCommSpec = nullptr; + ConstructEccKeyPairCommParamsSpec("NID_sm2", &eccCommSpec); + ASSERT_NE(eccCommSpec, nullptr); HcfAsyKeyParamsSpec *paramSpec = nullptr; - HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), g_eccCommSpec, ¶mSpec); + HcfResult res = ConstructEccKeyPairParamsSpec(g_sm2AlgName.c_str(), eccCommSpec, ¶mSpec); ASSERT_EQ(res, HCF_SUCCESS); ASSERT_NE(paramSpec, nullptr); @@ -1000,6 +1040,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(eccCommSpec); } @@ -1026,6 +1067,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest040, TestSize.Level0) @@ -1053,6 +1095,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest041, TestSize.Level0) @@ -1080,6 +1123,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } @@ -1108,6 +1152,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } @@ -1136,6 +1181,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest044, TestSize.Level0) @@ -1163,6 +1209,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest045, TestSize.Level0) @@ -1190,6 +1237,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest046, TestSize.Level0) @@ -1221,6 +1269,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest047, TestSize.Level0) @@ -1252,6 +1301,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest048, TestSize.Level0) @@ -1283,6 +1333,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest049, TestSize.Level0) @@ -1308,6 +1359,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(keyPair); HcfObjDestroy(generator); DestroyEccKeyPairSpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest050, TestSize.Level0) @@ -1332,6 +1384,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest051, TestSize.Level0) @@ -1356,6 +1409,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest052, TestSize.Level0) @@ -1377,6 +1431,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest053, TestSize.Level0) @@ -1398,6 +1453,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest054, TestSize.Level0) @@ -1425,6 +1481,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest055, TestSize.Level0) @@ -1450,6 +1507,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 pubKey->base.base.destroy((HcfObjectBase *)(&(pubKey->base.base))); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest056, TestSize.Level0) @@ -1475,6 +1533,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest057, TestSize.Level0) @@ -1500,6 +1559,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest058, TestSize.Level0) @@ -1527,6 +1587,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest059, TestSize.Level0) @@ -1554,6 +1615,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest060, TestSize.Level0) @@ -1581,6 +1643,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest061, TestSize.Level0) @@ -1608,6 +1671,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest062, TestSize.Level0) @@ -1635,6 +1699,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest063, TestSize.Level0) @@ -1662,6 +1727,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest064, TestSize.Level0) @@ -1694,6 +1760,7 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest065, TestSize.Level0) @@ -1726,5 +1793,6 @@ HWTEST_F(CryptoSm2AsyKeyGeneratorBySpecTest, CryptoSm2AsyKeyGeneratorBySpecTest0 HcfObjDestroy(pubKey); HcfObjDestroy(generator); DestroyEccPubKeySpec(reinterpret_cast(paramSpec)); + HcfFree(g_eccCommSpec); } } \ No newline at end of file -- Gitee